Agents

1. Generate AgentId (UUID v4) and SessionId
2. Create session in memory substrate
3. Parse manifest and extract capabilities
4. Validate capability inheritance
   ↳ Child cannot have more capabilities than parent
5. Grant capabilities via CapabilityManager
6. Register with AgentScheduler (quota tracking)
7. Create AgentEntry and register in AgentRegistry
8. Persist to SQLite via memory.save_agent()
9. If agent has parent, update parent's children list
10. Register proactive triggers (if schedule.mode = "proactive")
11. Publish Lifecycle::Spawned event
12. Evaluate triggers

use openfang_types::capability::{Capability, validate_capability_inheritance};

let parent_caps = vec![
    Capability::FileRead("/data/*".to_string()),
    Capability::NetConnect("api.example.com".to_string()),
];

let child_caps = vec![
    Capability::FileRead("/data/reports/*".to_string()),  // ✅ Subset of parent
    Capability::ShellExec("*".to_string()),                // ❌ Not granted to parent
];

// This will return Err — child cannot have ShellExec
validate_capability_inheritance(&parent_caps, &child_caps)?;

1. RBAC check
   AuthManager resolves channel identity and checks user role permissions

2. Channel policy check
   ChannelBridgeHandle.authorize_channel_user() enforces DM/group policy

3. Quota check
   AgentScheduler verifies agent hasn't exceeded token-per-hour limit

4. Entry lookup
   Fetch AgentEntry from registry

5. Module dispatch
   Based on manifest.module:
   - builtin:chat → LLM agent loop
   - wasm:path/to/module.wasm → WASM sandbox execution
   - python:path/to/script.py → Python subprocess execution

6. LLM agent loop (for builtin:chat)
   a. Load or create session from memory
   b. Load canonical context summary (cross-channel memory)
   c. Append stability guidelines to system prompt
   d. Resolve LLM driver (per-agent override or kernel default)
   e. Gather available tools (filtered by capabilities + skills + MCP)
   f. Initialize loop guard (tool loop detection)
   g. Run session repair (validate message history)
   h. Run iterative loop: send → LLM → tool calls → results
   i. Auto-compact session if threshold exceeded
   j. Save updated session and canonical session

7. Cost estimation
   MeteringEngine.estimate_cost_with_catalog() computes cost in USD

8. Record usage
   Update quota tracking with token counts
   Persist usage event to SQLite

9. Return result
   AgentLoopResult with response text, token usage, iterations, cost_usd

pub enum Capability {
    // File system
    FileRead(String),           // Read files matching glob pattern
    FileWrite(String),          // Write files matching glob pattern

    // Network
    NetConnect(String),         // Connect to hosts matching pattern
    NetListen(u16),             // Listen on specific port

    // Tools
    ToolInvoke(String),         // Invoke specific tool by ID
    ToolAll,                    // Invoke any tool (dangerous)

    // LLM
    LlmQuery(String),           // Query models matching pattern
    LlmMaxTokens(u64),          // Token budget cap

    // Agent interaction
    AgentSpawn,                 // Can spawn sub-agents
    AgentMessage(String),       // Can message agents matching pattern
    AgentKill(String),          // Can kill agents matching pattern

    // Memory
    MemoryRead(String),         // Read from memory scopes
    MemoryWrite(String),        // Write to memory scopes

    // Shell
    ShellExec(String),          // Execute shell commands
    EnvRead(String),            // Read environment variables

    // OFP (peer-to-peer)
    OfpDiscover,                // Can discover remote agents
    OfpConnect(String),         // Can connect to peers
    OfpAdvertise,               // Can advertise services

    // Economic
    EconSpend(f64),             // Can spend up to amount in USD
    EconEarn,                   // Can accept payments
    EconTransfer(String),       // Can transfer funds to agents
}

[capabilities]
agent_spawn = true

I need to analyze these logs in parallel. Let me spawn a log-analyzer agent.

<tool_use>
  <tool_name>agent_spawn</tool_name>
  &lt;parameters&gt;
    &lt;manifest&gt;
      name = "log-analyzer"
      description = "Analyzes application logs for errors"
      module = "builtin:chat"
      [model]
      provider = "groq"
      model = "llama-3.3-70b-versatile"
      [capabilities]
      tools = ["file_read", "memory_store"]
      memory_write = ["self.*"]
    &lt;/manifest&gt;
  &lt;/parameters&gt;
&lt;/tool_use&gt;

[capabilities]
agent_message = ["summarizer", "translator"]

I've completed the research. Let me send the report to the summarizer agent.

<tool_use>
  <tool_name>agent_message</tool_name>
  &lt;parameters&gt;
    <target_agent_name>summarizer</target_agent_name>
    <message>Please summarize this 50-page research report into 3 key findings...</message>
  &lt;/parameters&gt;
&lt;/tool_use&gt;

Warn threshold (default 3): Logs warning + injects hint to LLM
Block threshold (default 5): Refuses tool call + returns error
Circuit breaker (default 30): Terminates agent loop entirely

[Output truncated: 125,432 bytes → 50,000 bytes]

STABILITY GUIDELINES
- If a tool call fails twice, try a different approach
- If you're repeating the same action, stop and reflect
- If you're unsure, ask the user instead of guessing
- If a task is blocked, report the blocker clearly
- Never retry the same failed operation more than 3 times