RockBot

https://rockbot.dev
Admin
RockBot is an event-driven, process-isolated autonomous agent framework for .NET designed to build...
Tokens:31,302
Snippets:430
Trust Score:3.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Agent Context Hint Example

Source: https://rockbot.dev/tools

Example of the context injected into the system prompt by AgentContextBuilder.

```text
Potentially relevant services for this request (call search_known_services for full search):
- SalesOpsAgent (a2a): Autonomous agent for complex sales workflows, top skills: generate-qbr-report
- salesforce-mcp (mcp): Direct Salesforce CRM access, top tools: search_leads, update_opportunity
```

--------------------------------

### Start RockBot Services

Source: https://rockbot.dev/getting-started-docker-desktop.html

Navigate to the deployment directory and launch the services in detached mode.

```bash
cd deploy/docker-compose
docker compose up -d
```

--------------------------------

### Initialize environment configuration

Source: https://rockbot.dev/getting-started-docker-desktop.html

Copy the example environment file to create a local configuration file.

```bash
cp deploy/docker-compose/.env.example deploy/docker-compose/.env
```

--------------------------------

### Define an IToolSkillProvider

Source: https://rockbot.dev/tools

Implement this interface to register a tool guide provider that exposes a name, summary, and full markdown documentation.

```csharp
public interface IToolSkillProvider
{
    string Name { get; }       // e.g. "web-tools", "mcp-tool-guide"
    string Summary { get; }    // One-line description
    string GetDocument();      // Full markdown guide
}
```

--------------------------------

### View Batch Execution Summary

Source: https://rockbot.dev/wisps.html

Example output format for a batch of completed wisps, showing status, duration, and summary location.

```text
5 wisp(s) completed (5 succeeded, 0 failed, 10.7s total):

- `wisp-abc`: "Search marimer emails" [ok] (1180ms)
  Output: ...
- `wisp-def`: "Search xebia emails" [ok] (2733ms)
  Output: ...
...

Batch ID: `batch-abc123def456ab`
Batch summary: `wisp/batch-batch-abc123def456ab/summary`
```

--------------------------------

### BM25 Recall Output Example

Source: https://rockbot.dev/memory.html

Example of the format returned by the BM25 search process during a session.

```text
Recalled from long-term memory (relevant to this message):
- [abc123def456] (user-preferences/timezone): User is in Chicago (America/Chicago, UTC-6)
- [xyz789abc012] (anti-patterns/file-operations): Don't use search_files for content search — use grep; BM25 recall is faster and more accurate

```

--------------------------------

### Define Cron Expressions

Source: https://rockbot.dev/tools

Examples of 5-field and 6-field cron expressions for task scheduling.

```text
# 5-field: minute hour day-of-month month day-of-week
0 9 * * 1-5        # 9 AM every weekday
*/15 * * * *       # every 15 minutes

# 6-field: second minute hour day-of-month month day-of-week
0 0 9 * * 1-5      # 9:00:00 AM every weekday
```

--------------------------------

### Session-level skill index format

Source: https://rockbot.dev/skills.html

The initial list of available skills injected into the system prompt at the start of a session.

```text
Available skills (use get_skill to load full instructions):
- mcp/email: Send email via an MCP-connected mail server
- plan-meeting: Schedule meetings and invite attendees
- research/summarize-paper: Summarize an academic paper into key points

```

--------------------------------

### Perform breadth-first graph traversal

Source: https://rockbot.dev/knowledge-graph.html

Demonstrates the traversal logic starting from a seed entity with a defined hop limit.

```text
Seed: [Alice]     MaxHops: 2

Hop 1: Alice --works_on--> RockBot         (RockBot added to frontier)
Hop 2: RockBot --uses--> RabbitMQ          (RabbitMQ added to frontier)
        Bob --works_on--> RockBot           (Bob already discovered via object match)
```

--------------------------------

### View Injected Working Memory Context

Source: https://rockbot.dev/memory.html

Example of how working memory entries are presented to the agent during a session turn.

```text
Working memory (scratch space — use search_working_memory or get_from_working_memory to retrieve):
- session/abc123/emails_inbox: expires in 4m32s, category: email, tags: inbox, unread
- session/abc123/draft_reply: expires in 2m01s
```

```text
Patrol findings in working memory (use get_from_working_memory with the full key to read):
- patrol/heartbeat/latest-briefing: expires in 4h12m, category: patrol-finding
- patrol/heartbeat/alerts: expires in 4h08m, tags: urgent
```

--------------------------------

### SendMessage JSON-RPC Request

Source: https://rockbot.dev/a2a.html

Example cURL command to send a message to the gateway using the SendMessage method.

```bash
curl -X POST http://localhost:5200/ \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: my-key" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "SendMessage",
    "params": {
      "message": { "role": "user", "parts": [{ "text": "What is the weather?" }] },
      "metadata": { "skill": "notify-user" }
    }
  }'
```

--------------------------------

### Configure model-specific tool chunking threshold

Source: https://rockbot.dev/agent-host.html

Example of overriding the default tool result chunking threshold for a specific model in appsettings.json.

```json
{
  "ModelBehaviors": {
    "Models": {
      "openrouter/deepseek": {
        "ToolResultChunkingThreshold": 32000
      }
    }
  }
}
```

--------------------------------

### Perform Cross-Namespace Working Memory Operations

Source: https://rockbot.dev/memory.html

Examples of retrieving and searching for data stored in namespaces other than the current caller's.

```python
# See what a completed subagent stored
list_working_memory(namespace: "subagent/t1b2c3")
get_from_working_memory("subagent/t1b2c3/research_results")

# Browse all patrol outputs
list_working_memory(namespace: "patrol")
search_working_memory(query: "alert", namespace: "patrol/heartbeat")
```

--------------------------------

### Web Search Configuration

Source: https://rockbot.dev/tools

Configuration options for the web search tool, including API key setup and result limits.

```csharp
opts.ApiKey = "...";           // or opts.ApiKeyEnvVar = "BRAVE_API_KEY"
opts.MaxSearchResults = 5;     // default
```

--------------------------------

### SSE Streaming Response Format

Source: https://rockbot.dev/a2a.html

Example of the JSON-RPC 2.0 result format returned within Server-Sent Events for streaming methods.

```text
data: {"jsonrpc":"2.0","id":1,"result":{"statusUpdate":{"taskId":"abc","status":{"state":"working"}}}}

data: {"jsonrpc":"2.0","id":1,"result":{"message":{"role":"agent","parts":[{"text":"Done."}]}}}
```

--------------------------------

### GET /.well-known/agent.json

Source: https://rockbot.dev/a2a.html

Retrieves the AgentCard metadata describing the agent's capabilities and identity.

```APIDOC
## GET /.well-known/agent.json

### Description
Returns the AgentCard object which contains information about the agent, including its name, version, description, and supported skills.

### Method
GET

### Endpoint
/.well-known/agent.json

### Response
#### Success Response (200)
- **AgentCard** (object) - The metadata object describing the agent.
```

--------------------------------

### Configure Script Runners

Source: https://rockbot.dev/tools

Registration methods for local development versus production remote execution.

```csharp
// Development
agent.AddLocalScriptRunner();

// Production
agent.AddRemoteScriptRunner(agentName: identity.Name);
```

--------------------------------

### GET /.well-known/agent-card.json

Source: https://rockbot.dev/a2a.html

Retrieves the agent card containing capabilities and security schemes for A2A discovery.

```APIDOC
## GET /.well-known/agent-card.json

### Description
Returns the agent card with capabilities and security schemes for A2A discovery.

### Method
GET

### Endpoint
/.well-known/agent-card.json
```

--------------------------------

### Register Dream Service with DI

Source: https://rockbot.dev/dream-service.html

Configures the Dream Service using the builder pattern. Optional dependencies default to null, allowing for graceful degradation.

```csharp
builder
    .WithMemory()              // ILongTermMemory — required
    .WithSkills()              // ISkillStore + ISkillUsageStore — required for skill passes
    .WithConversationLog()     // IConversationLog — required for gap detection + preference inference
    .WithFeedback()            // IFeedbackStore — required for optimization + anti-pattern mining
    .WithDreaming(opts =>
    {
        opts.Interval = TimeSpan.FromHours(2);   // run more frequently
        opts.SkillGapEnabled = false;            // disable gap detection
    });
```

--------------------------------

### Register Web Tools via Dependency Injection

Source: https://rockbot.dev/tools

Configures web tool settings during service registration, including chunking thresholds and TTL.

```csharp
agent.AddWebTools(opts =>
{
    opts.ApiKey = config["WebTools:ApiKey"];
    opts.ChunkingThreshold = 8000;
    opts.ChunkMaxLength = 4000;
    opts.ChunkTtlMinutes = 30;
});
```

--------------------------------

### Register Wisp services via DI

Source: https://rockbot.dev/wisps.html

Configures the Wisp execution environment by specifying the shared volume path.

```csharp
agent.AddWisps(opts =>
    opts.SharedVolumePath = "/rockbot/shared");
```

--------------------------------

### get_agent_details(agent_name)

Source: https://rockbot.dev/a2a.html

Retrieves the full agent card for a specific agent, including skills, tags, examples, and URL.

```APIDOC
## get_agent_details(agent_name)

### Description
Fetches the complete agent card for the specified agent name.

### Parameters
- **agent_name** (string) - Required - The name of the agent to retrieve details for.
```

--------------------------------

### Test Packaging Locally

Source: https://rockbot.dev/nuget-release.html

Scripts to generate NuGet packages locally without publishing, optionally specifying a version.

```bash
# Default version (from build.number file, falls back to 0.3.0)
./pack.sh

# Specific version
./pack.sh 0.4.0-beta001
```

--------------------------------

### Define FileSkillStore path format

Source: https://rockbot.dev/skills.html

Skills are persisted as JSON files within the agent data directory.

```text
{agentDataPath}/skills/{name}.json
```

--------------------------------

### AddRockBotHost Configuration

Source: https://rockbot.dev/agent-host.html

The AddRockBotHost method is the entry point for configuring an agent host, allowing for the registration of identity, memory tiers, skills, and message handlers.

```APIDOC
## AddRockBotHost

### Description
Configures the agent host using a fluent builder pattern. This method registers core services such as identity, memory, skills, and message handlers.

### Method
Extension Method (IServiceCollection)

### Parameters
- **agent** (AgentHostBuilder) - Required - The builder instance used to configure the agent.

### Configuration Methods
- **WithIdentity(name)**: Registers AgentIdentity.
- **WithProfile()**: Registers IAgentProfileProvider, AgentProfile, and ISystemPromptBuilder.
- **WithRules()**: Registers IRulesStore and rules tools.
- **WithConversationMemory()**: Registers IConversationMemory.
- **WithLongTermMemory()**: Registers ILongTermMemory.
- **WithWorkingMemory()**: Registers IWorkingMemory.
- **WithMemory()**: Registers all three memory tiers.
- **WithConversationLog()**: Registers IConversationLog.
- **WithFeedback()**: Registers IFeedbackStore and SessionSummaryService.
- **WithSkills()**: Registers ISkillStore, ISkillUsageStore, and StarterSkillService.
- **WithDreaming(opts)**: Registers DreamService.
- **HandleMessage<TMessage, THandler>()**: Registers a message handler for a specific message type.
- **AddToolHandler()**: Registers tool invocation dispatch.
- **AddMcpToolProxy()**: Registers MCP server bridge.
- **AddWebTools(opts)**: Registers web search and browse tools.
- **AddSchedulingTools()**: Registers scheduled task tools.
- **AddRemoteScriptRunner()**: Registers script execution via Scripts Manager.
- **SubscribeTo(topic)**: Subscribes the agent to a specific message topic.
- **UseMiddleware<T>()**: Registers custom middleware.
```

--------------------------------

### Register Service Search via DI

Source: https://rockbot.dev/tools

Configure the service search tool and associated providers in the dependency injection container.

```csharp
agent.AddServiceSearch();   // registers search_known_services tool + IServiceSearchIndex
                             // + ServiceSearchSkillProvider (tool guide)
                             // + per-turn context hints in AgentContextBuilder
```

--------------------------------

### Register Blazor services in Program.cs

Source: https://rockbot.dev/blazor-ui.html

Configures RabbitMQ and registers the necessary services for the Blazor UI.

```csharp
builder.Services.AddRockBotRabbitMq(opts =>
    builder.Configuration.GetSection("RabbitMq").Bind(opts));
builder.Services.AddUserProxy();
builder.Services.AddSingleton<IUserFrontend, BlazorUserFrontend>();
builder.Services.AddSingleton<ChatStateService>();
```

--------------------------------

### Push Packages Manually

Source: https://rockbot.dev/nuget-release.html

Command to manually push packages to nuget.org using a provided API key.

```bash
./push.sh YOUR_NUGET_API_KEY
```

--------------------------------

### Configure GitHub Copilot LLM

Source: https://rockbot.dev/getting-started-docker-desktop.html

Set these variables in your .env file to use GitHub Copilot as the LLM provider.

```text
LLM_PROVIDER=Copilot
LLM_MODEL_ID=gpt-4.1
GITHUB_TOKEN=ghp_your-token-with-copilot-scope
```

--------------------------------

### Register Skill Services via Dependency Injection

Source: https://rockbot.dev/skills.html

Configures the service builder to include skill stores, logging, feedback, and dreaming capabilities.

```csharp
builder
    .WithSkills()                    // FileSkillStore + FileSkillUsageStore + StarterSkillService
    .WithConversationLog()           // Required for skill gap detection
    .WithFeedback()                  // Required for skill optimization
    .WithDreaming()                  // Enables all dream passes
```

--------------------------------

### Register RockBot services via DI

Source: https://rockbot.dev/tools

Configures the RockBot host by registering core infrastructure and specific tool subsystems within the AddRockBotHost delegate.

```csharp
services.AddRockBotHost(agent =>
{
    // Core tool infrastructure (required for all tools)
    agent.AddToolHandler();             // IToolRegistry + ToolGuideTools + ToolInvokeHandler

    // Tool subsystems (add as needed)
    agent.AddMcpToolProxy();            // MCP management tools (message-bus proxy to bridge)
    // OR:
    agent.AddMcpTools(opts => ...);     // MCP bridge in-process (no message-bus hop)

    agent.AddWebTools(opts => ...);     // web_search + web_browse
    agent.AddSchedulingTools();         // schedule_task + list/cancel
    agent.AddSubagents();               // spawn_subagent + cancel/list + whiteboard
    agent.AddWisps(opts => ...);        // spawn_wisps (lightweight procedural pipelines, parallel batches)
    agent.AddRemoteScriptRunner();      // execute_python_script (Kubernetes)
    // OR:
    agent.AddLocalScriptRunner();       // execute_python_script (local dev)

    agent.AddA2ACaller(opts => ...);    // invoke_agent + list_known_agents + get_agent_details
    agent.AddServiceSearch();           // search_known_services (after AddA2ACaller + AddMcpToolProxy)
});
```

--------------------------------

### Recurring Topic Frequency Signal

Source: https://rockbot.dev/dream-service.html

Example of the quantitative signal provided to the LLM to identify recurring user needs across sessions.

```text
Recurring topics across sessions (term frequency ≥ 2 sessions):
- "email": 4 session(s)
- "summarize": 3 session(s)
```

--------------------------------

### Configure OpenRouter MCP Server

Source: https://rockbot.dev/tools

Enable the OpenRouter MCP server and provide the management API key in the Helm values file.

```yaml
# In values.personal.yaml
openrouterMcp:
  enabled: true
secrets:
  openRouter:
    apiKey: "<your-openrouter-management-api-key>"
```

--------------------------------

### Configure LLM provider environment variables

Source: https://rockbot.dev/getting-started-docker-desktop.html

Environment variable configurations for OpenAI-compatible and GitHub Copilot LLM providers.

```text
LLM_API_KEY=sk-or-v1-your-openrouter-key-here
LLM_ENDPOINT=https://openrouter.ai/api/v1
LLM_MODEL_ID=anthropic/claude-haiku-4.5
BRAVE_API_KEY=BSA-your-brave-key-here
```

```text
LLM_PROVIDER=Copilot
LLM_MODEL_ID=gpt-4.1
GITHUB_TOKEN=ghp_your-token-with-copilot-scope
BRAVE_API_KEY=BSA-your-brave-key-here
```

--------------------------------

### Configure local Ollama LLM

Source: https://rockbot.dev/getting-started-docker-desktop.html

Set these variables in your .env file to use a local Ollama instance as the LLM provider.

```text
LLM_ENDPOINT=http://host.docker.internal:11434/v1
LLM_API_KEY=ollama
LLM_MODEL_ID=llama3.1
```

--------------------------------

### Create Release Branches

Source: https://rockbot.dev/nuget-release.html

Commands to create stable or pre-release branches from main to trigger the automated release workflow.

```bash
# Stable release
git checkout main && git pull
git checkout -b release/v0.4.0
git push origin release/v0.4.0

# Pre-release
git checkout main && git pull
git checkout -b release/v0.4.0-beta001
git push origin release/v0.4.0-beta001
```

--------------------------------

### Subagent Data Handoff Pattern

Source: https://rockbot.dev/subagents.html

Demonstrates the lifecycle of data handoff, from spawning a subagent and saving results to memory, to retrieval by the primary agent.

```text
Primary agent (before spawning):
  spawn_subagent("Scrape [url1, url2, url3] and summarize findings")

Subagent (runs in namespace "subagent/abc123"):
  [fetches urls]
  save_to_working_memory("url1_content", "...", ttl_minutes=240, category="scrape-result")
    → stored at "subagent/abc123/url1_content"
  save_to_working_memory("summary", "...", ttl_minutes=240)
    → stored at "subagent/abc123/summary"
  ReportProgress("Done. Results saved: url1_content, summary")

Primary agent (on result, via SubagentResultHandler):
  # SubagentResultHandler checks for entries in "subagent/abc123/" and includes a hint if found:
  # "[Subagent task abc123 completed]: ... Additional outputs were written to working memory.
  #  Keys: 'subagent/abc123/url1_content', 'subagent/abc123/summary'. Retrieve and present them."
  list_working_memory(namespace: "subagent/abc123")
  get_from_working_memory("subagent/abc123/summary")
```

--------------------------------

### Configure Knowledge Graph Options

Source: https://rockbot.dev/knowledge-graph.html

Defines the settings for the knowledge graph, including base path, BFS depth, and triple injection limits.

```csharp
public sealed class KnowledgeGraphOptions
{
    public string BasePath { get; set; } = "knowledge-graph";   // Relative to agent data path
    public int MaxHops { get; set; } = 2;                       // BFS depth for context expansion
    public int MaxExpandedTriples { get; set; } = 15;           // Max triples injected per turn
}
```

--------------------------------

### Configure MCP Servers

Source: https://rockbot.dev/tools

Define MCP server connections in the application configuration file.

```json
{
  "Mcp": {
    "Servers": [
      {
        "Name": "weather-server",
        "Command": "uvx",
        "Arguments": ["mcp-server-weather"],
        "EnvironmentVariables": { "API_KEY": "..." }
      }
    ]
  }
}
```

--------------------------------

### Memory Injection Workflow

Source: https://rockbot.dev/memory.html

Outlines the sequence of operations performed during each turn to inject relevant memory context.

```text
1. BM25 search: longTermMemory.SearchAsync(Query: message.Content, MaxResults: 8)
2. Fallback (first turn only): SearchAsync(MaxResults: 5) if no BM25 results
3. Delta filter: only entries not yet injected this session (InjectedMemoryTracker)
4. Inject as system message: "Recalled from long-term memory..."
5. Inject working memory inventory for own namespace: workingMemory.ListAsync("session/{sessionId}")
6. [User sessions only] Inject patrol findings: workingMemory.ListAsync("patrol") — shows the
   agent what patrol tasks have stored since the last run, without fetching content
7. [User sessions only] Inject subagent research outlines: workingMemory.ListAsync("subagent") —
   filters to `-index` keys only, showing the agent what prior subagent research is available
   in working memory without listing every content chunk. The agent can retrieve an index to
   see the document outline and navigate to specific chunks.
8. Replay last 20 conversation turns
```

--------------------------------

### Test MCP Server Integration

Source: https://rockbot.dev/getting-started-rockbot.html

Verify connectivity by requesting the agent to perform a real task using the newly connected server.

```text
Check my calendar for today and summarize anything important.
```

```text
Look at my next 7 days of meetings and tell me where I look overloaded.
```

--------------------------------

### Register Scheduling Tools

Source: https://rockbot.dev/tools

Register the scheduling tools with the agent via dependency injection.

```csharp
agent.AddSchedulingTools();
```

--------------------------------

### Implementing Per-Skill Handlers

Source: https://rockbot.dev/a2a.html

Use IAgentSkillHandler for agents with multiple skills to enable automatic metadata population and framework-level dispatching.

```csharp
public sealed class EchoSkillHandler : IAgentSkillHandler
{
    public AgentSkill Skill { get; } = new()
    {
        Id = "echo",
        Name = "Echo",
        Description = "Echoes the input message back."
    };

    public Task<AgentTaskResult> ExecuteAsync(
        AgentTaskRequest request, AgentTaskContext context) => /* ... */;
}

agent.AddA2A(opts => opts.Card = new AgentCard { AgentName = "MyAgent", Version = "1.0" })
     .AddSkillHandler<EchoSkillHandler>()
     .AddSkillHandler<SearchSkillHandler>();
```

--------------------------------

### Initialize Multi-turn Context

Source: https://rockbot.dev/a2a.html

Use the request context or task ID to maintain session continuity for multi-turn skills.

```csharp
var contextId = request.ContextId ?? request.TaskId;
var sessionId = $"a2a-inbound/{contextId}";
```

--------------------------------

### Configure AgentHostBuilder with AddRockBotHost

Source: https://rockbot.dev/agent-host.html

Use this fluent API to register agent identity, memory providers, message handlers, and tool subsystems within the service collection.

```csharp
services.AddRockBotHost(agent =>
{
    agent.WithIdentity("rockbot");
    agent.WithProfile();                 // Load soul.md, directives.md, etc. from data volume
    agent.WithRules();                   // Load agent rules from rules/ directory
    agent.WithMemory();                  // Conversation + long-term + working memory
    agent.WithConversationLog();         // Opt-in: enables dream gap detection + pref inference
    agent.WithFeedback();                // IFeedbackStore + SessionSummaryService
    agent.WithSkills();                  // ISkillStore + ISkillUsageStore + StarterSkillService
    agent.WithDreaming(opts =>
    {
        opts.InitialDelay = TimeSpan.FromMinutes(5);
        opts.Interval = TimeSpan.FromHours(4);
    });

    // Message handlers
    agent.HandleMessage<UserMessage, UserMessageHandler>();
    agent.HandleMessage<ConversationHistoryRequest, ConversationHistoryRequestHandler>();
    agent.HandleMessage<ScheduledTaskMessage, ScheduledTaskHandler>();

    // Tool subsystems
    agent.AddToolHandler();              // Tool invocation dispatch
    agent.AddMcpToolProxy();             // MCP server bridge
    agent.AddWebTools(opts => { ... });  // Web search + browse
    agent.AddSchedulingTools();          // Scheduled task tools
    agent.AddRemoteScriptRunner();       // Script execution via Scripts Manager

    // Subscriptions
    agent.SubscribeTo(UserProxyTopics.UserMessage);
    agent.SubscribeTo(UserProxyTopics.ConversationHistoryRequest);

    // Optional middleware
    agent.UseMiddleware<LoggingMiddleware>();
    agent.UseMiddleware<TracingMiddleware>();
    agent.UseMiddleware<ErrorHandlingMiddleware>();
});
```

--------------------------------

### Registering a Queue-based A2A Agent

Source: https://rockbot.dev/a2a.html

Configure the agent in Program.cs by adding A2A options and registering the IAgentTaskHandler.

```csharp
agent.AddA2A(opts =>
{
    opts.Card = new AgentCard
    {
        AgentName = "MyAgent",
        Description = "What this agent does.",
        Version = "1.0",
        Skills = [new AgentSkill { Id = "my-skill", Name = "My Skill", Description = "..." }]
    };
});

agent.Services.AddScoped<IAgentTaskHandler, MyAgentTaskHandler>();
```

--------------------------------

### Agent Host Configuration Reference

Source: https://rockbot.dev/agent-host.html

Configuration structure for the agent host, including LLM endpoints, RabbitMQ connection details, and service-specific settings.

```json
{
  "AgentProfile": {
    "BasePath": "/data/agent"
  },
  "AgentHost": {
    "MaxToolIterations": 50,
    "MaxCompletionReprompts": 2,
    "MaxFollowUpPasses": 1
  },
  "RabbitMq": {
    "HostName": "rabbitmq.cluster.local",
    "Port": 5672,
    "UserName": "rockbot",
    "Password": "..."
  },
  "LLM": {
    "Balanced": {
      "Endpoint": "https://openrouter.ai/api/v1",
      "ApiKey": "...",
      "ModelId": "anthropic/claude-haiku-4.5"
    },
    "Low": {
      "Endpoint": "https://openrouter.ai/api/v1",
      "ApiKey": "...",
      "ModelId": "google/gemini-flash-1.5-8b"
    },
    "High": {
      "Endpoint": "https://openrouter.ai/api/v1",
      "ApiKey": "...",
      "ModelId": "anthropic/claude-opus-4-6"
    }
  },
  "Memory": {
    "BasePath": "memory"
  },
  "Skills": {
    "BasePath": "skills",
    "UsageBasePath": "skill-usage"
  },
  "Dream": {
    "Enabled": true,
    "InitialDelay": "00:05:00",
    "Interval": "04:00:00",
    "TierRoutingReviewEnabled": true
  },
  "Feedback": {
    "BasePath": "feedback",
    "SessionIdleThreshold": "00:10:00",
    "PollInterval": "00:05:00"
  }
}
```

--------------------------------

### Configure Skill and Dream Options

Source: https://rockbot.dev/skills.html

Defines the directory paths and feature flags for skill management and dream-based optimization.

```csharp
public sealed class SkillOptions
{
    public string BasePath { get; set; } = "skills";          // Relative to agent data path
    public string UsageBasePath { get; set; } = "skill-usage"; // Relative to agent data path
}
```

```csharp
public sealed class DreamOptions
{
    public string SkillDirectivePath { get; set; } = "skill-dream.md";       // Consolidation prompt
    public string SkillOptimizeDirectivePath { get; set; } = "skill-optimize.md"; // Optimization prompt
    public string SkillGapDirectivePath { get; set; } = "skill-gap.md";       // Gap detection prompt
    public bool SkillGapEnabled { get; set; } = true;
}
```

--------------------------------

### Sparse Skill Review Prompt

Source: https://rockbot.dev/skills.html

Template used to flag sparse skills for expansion during the optimization pass.

```markdown
## Skill: mcp/email [SPARSE]
...
### Review note: This skill has minimal content. Expand it with concrete steps, examples, and edge cases.

```

--------------------------------

### Configure RabbitMQ Options

Source: https://rockbot.dev/messaging

Defines the configuration class for RabbitMQ connection and exchange settings.

```csharp
public sealed class RabbitMqOptions
{
    public string HostName { get; set; } = "localhost";
    public int Port { get; set; } = 5672;
    public string UserName { get; set; } = "guest";
    public string Password { get; set; } = "guest";
    public string VirtualHost { get; set; } = "/";
    public string ExchangeName { get; set; } = "rockbot";
    public string DeadLetterExchangeName { get; set; } = "rockbot.dlx";
    public bool Durable { get; set; } = true;
    public ushort PrefetchCount { get; set; } = 10;
}
```

--------------------------------

### Dream Service Execution Schedule

Source: https://rockbot.dev/dream-service.html

Visual representation of the startup delay and interval-based execution cycle for the dream service.

```text
Startup
  └── InitialDelay (default 5 min)
        └── DreamCycle
              └── Interval (default 4 hrs)
                    └── DreamCycle
                          └── ...
```

--------------------------------

### web_browse(url)

Source: https://rockbot.dev/tools

Fetches a web page, strips noise, converts content to markdown, and handles large pages via chunking.

```APIDOC
## web_browse(url)

### Description
Fetches a web page, removes non-essential elements (scripts, styles, nav, etc.), and converts the remaining content to markdown. For large pages, content is automatically chunked and stored in working memory.

### Parameters
- **url** (string) - Required - The URL of the page to browse.

### Notes
- GitHub issue and PR URLs are automatically routed through the GitHub REST API for structured data retrieval.
```

--------------------------------

### View Service Logs

Source: https://rockbot.dev/getting-started-docker-desktop.html

Commands to view logs for the agent specifically or for all services in the stack.

```bash
# Agent logs
docker compose logs -f agent

# All services
docker compose logs -f
```

--------------------------------

### Manual MCP Configuration

Source: https://rockbot.dev/getting-started-rockbot.html

Define an MCP server entry in mcp.json, including optional attachment passthrough settings.

```json
{
  "mcpServers": {
    "calendar-mcp": {
      "type": "sse",
      "url": "http://host.docker.internal:3000/",
      "attachments": {
        "outbound": { "paramPaths": ["attachments[*]"] },
        "inbound":  { "tools": ["get_email_attachment"] }
      }
    }
  }
}
```

--------------------------------

### Skill Usage Log Path

Source: https://rockbot.dev/skills.html

The file path pattern for session-based skill invocation logs.

```text
{agentDataPath}/skill-usage/{sessionId}.jsonl
```

--------------------------------

### See-also skill injection

Source: https://rockbot.dev/skills.html

The format for injecting related skills discovered through see-also references.

```text
Related skills (see-also): mcp/guide, mcp/calendar

```

--------------------------------

### Define UserProxyOptions class

Source: https://rockbot.dev/blazor-ui.html

Configuration class for proxy instance identification and reply timeouts.

```csharp
public sealed class UserProxyOptions
{
    public string ProxyId { get; set; }          // Unique identifier for this proxy instance
    public TimeSpan DefaultReplyTimeout { get; set; }  // How long to wait for an agent reply
}
```

--------------------------------

### FileFeedbackStore Path Structure

Source: https://rockbot.dev/agent-host.html

The storage path format for per-session feedback records.

```text
{BasePath}/{sessionId}.jsonl
```

--------------------------------

### Register Gateway Skill in appsettings.json

Source: https://rockbot.dev/a2a.html

Add the skill to the gateway configuration so HTTP callers can identify it.

```json
{ "Id": "my-skill", "Name": "My Skill", "Description": "..." }
```

--------------------------------

### Follow Agent Logs

Source: https://rockbot.dev/getting-started-docker-desktop.html

Monitor the agent's logs to verify successful connection to RabbitMQ.

```bash
docker compose logs -f agent
```

--------------------------------

### Query Agent Beliefs and Improvements

Source: https://rockbot.dev/getting-started-rockbot.html

Use these prompts during the initial feedback loop to assess the agent's current understanding of the user, itself, and potential system improvements.

```text
What do you currently believe about me that is important for helping me well?
```

```text
What do you currently believe about yourself, your role, and your strengths and limitations?
```

```text
What scheduled tasks, MCP tools, or memory rules would make you noticeably more helpful?
```

--------------------------------

### Script Execution Workflow

Source: https://rockbot.dev/tools

The message bus flow for executing scripts in a production Kubernetes environment.

```text
Agent: execute_python_script(...)
    │
    ▼
MessageBusScriptRunner
    │   Publishes ScriptInvokeRequest to "script.invoke"
    │   Awaits on "script.result.{agentName}"
    │
    ▼
Scripts Manager (trusted sidecar, separate pod)
    │   Has Kubernetes API access
    │   Creates ephemeral pod in "rockbot-scripts" namespace
    │   python:3.12-slim, 500m CPU, 256Mi RAM
    │   No network access, no persistent storage
    │   Runs script, streams stdout
    │   Deletes pod immediately after completion
    │
    ▼
ScriptInvokeResponse on "script.result.{agentName}"
```

--------------------------------

### Provide user identity context

Source: https://rockbot.dev/getting-started-rockbot.html

Initial prompts to establish user identity and preferences in the agent's long-term memory.

```text
My name is Rocky. Please call me Rocky.
```

```text
Remember that I am in America/Chicago and I prefer concise, direct answers.
```

```text
Remember that I use RockBot mainly for communications, scheduling, technical work, and research.
```

--------------------------------

### Define IToolRegistry interface

Source: https://rockbot.dev/tools

Central directory interface for managing tool registrations and their associated executors.

```csharp
public interface IToolRegistry
{
    IReadOnlyList<ToolRegistration> GetTools();
    IToolExecutor? GetExecutor(string name);
    void Register(ToolRegistration registration, IToolExecutor executor);
    void Unregister(string name);
}
```

--------------------------------

### Register Knowledge Graph via DI

Source: https://rockbot.dev/knowledge-graph.html

Registers the knowledge graph service with the agent builder, supporting both default and custom configuration options.

```csharp
builder
    .WithKnowledgeGraph()                               // Defaults
    .WithKnowledgeGraph(o =>                             // Custom options
    {
        o.MaxHops = 3;
        o.MaxExpandedTriples = 20;
    });
```

--------------------------------

### Visualize MCP Tool Invocation Flow

Source: https://rockbot.dev/tools

Sequence diagram illustrating the remote tool invocation process between the agent and the MCP bridge.

```text
Agent: mcp_invoke_tool(server_name, tool_name, args)
    │
    ▼
McpManagementExecutor → McpToolProxy
    │   Publishes ToolInvokeRequest to "tool.invoke.mcp"
    │   rb-mcp-server: {server_name}
    │
    ▼
McpBridge (tools process)
    │   McpToolExecutor.ExecuteAsync()
    │   → calls MCP server via SSE
    │
    ▼
ToolInvokeResponse on "tool.result.{agentName}"
    │   Correlated by ToolCallId
```

--------------------------------

### Wisp Execution Architecture Flow

Source: https://rockbot.dev/wisps.html

Visual representation of the Wisp execution lifecycle from spawning to result return.

```text
Calling agent (primary or subagent)
┌─────────────────────────────────────────────────────────┐
│                                                         │
│  LLM calls spawn_wisps(definitions: [{ ... }])          │
│     │                                                   │
│     ▼                                                   │
│  SpawnWispsExecutor.ExecuteAsync()                      │
│     │  Parses WispDefinition[] from JSON                │
│     │  Generates batch ID + per-wisp IDs                │
│     │  Runs wisps concurrently (semaphore-gated)        │
│     │                                                   │
│     ▼                                                   │
│  WispExecutor.ExecuteAsync()                            │
│     │  For each step:                                   │
│     │    ├── Direct: GatewayRouter → IToolExecutor      │
│     │    │   (zero LLM tokens)                          │
│     │    └── Llm: AgentLoopRunner.RunAsync()            │
│     │        (minimal context, Low tier)                │
│     │                                                   │
│     ▼                                                   │
│  Returns WispExecutionResult (synchronous)              │
│     │  Per-step success/failure + content                │
│     │  Failure classification (structural/external/…)    │
│     │  Working memory namespace for detailed output      │
│                                                         │
│  [calling agent receives structured result immediately]  │
└─────────────────────────────────────────────────────────┘
```

--------------------------------

### System Prompt Structure

Source: https://rockbot.dev/agent-host.html

The template used by DefaultSystemPromptBuilder to assemble the agent's system prompt from profile documents.

```text
You are {AgentName}.

{soul.md content}

{directives.md content}

{memory-rules.md content}   ← if present

{style.md content}          ← if present
```

--------------------------------

### web_search(query, count?)

Source: https://rockbot.dev/tools

Executes a search query using the Brave Search API and returns results as a formatted markdown list.

```APIDOC
## web_search(query, count?)

### Description
Calls the Brave Search API to perform an internet search and returns a numbered markdown list of results.

### Parameters
- **query** (string) - Required - The search term to query.
- **count** (integer) - Optional - The number of search results to return.
```

--------------------------------

### Verify MCP Services

Source: https://rockbot.dev/getting-started-rockbot.html

Ask the agent to list and summarize currently available MCP services.

```text
List the MCP services you currently have available and summarize what each one is for.
```

--------------------------------

### Configure Memory Options

Source: https://rockbot.dev/memory.html

Defines the configuration classes for long-term memory, working memory, and dream passes.

```csharp
// Long-term memory
public sealed class MemoryOptions
{
    public string BasePath { get; set; } = "memory";   // Relative to agent data path
}

// Working memory
public sealed class WorkingMemoryOptions
{
    public TimeSpan DefaultTtl { get; set; } = TimeSpan.FromMinutes(5);
    public int MaxEntriesPerNamespace { get; set; } = 50;  // per first-two-segment namespace prefix
    public string BasePath { get; set; } = "working-memory";
}

// Dream passes
public sealed class DreamOptions
{
    public string DirectivePath { get; set; } = "dream.md";           // Memory consolidation prompt
    public string PreferenceDirectivePath { get; set; } = "pref-dream.md"; // Preference inference prompt
    public bool PreferenceInferenceEnabled { get; set; } = true;
}
```

--------------------------------

### Configure MCP Server Argument Guards

Source: https://rockbot.dev/tools

Define path-prefix validation rules within the mcpServers configuration to restrict tool argument values.

```json
{
  "mcpServers": {
    "onedrive-personal": {
      "type": "sse",
      "url": "http://onedrive-personal:3001/",
      "argGuards": [
        { "handler": "path-prefix",
          "tools": ["download_file"],
          "options": {
            "args": ["save_directory"],
            "allowedPrefixes": ["/rockbot/shared"],
            "requireArgs": true } }
      ]
    }
  }
}
```

--------------------------------

### schedule_task(name, cron, description, run_once?)

Source: https://rockbot.dev/tools

Creates or replaces a scheduled task using cron expressions.

```APIDOC
## schedule_task(name, cron, description, run_once?)

### Description
Create or replace a scheduled task. Supports 5-field (minute precision) and 6-field (second precision) cron expressions.

### Parameters
- **name** (string) - Required - Unique name for the task.
- **cron** (string) - Required - Cron expression for scheduling.
- **description** (string) - Required - Description of the task.
- **run_once** (boolean) - Optional - If true, the task is removed after it fires.
```

--------------------------------

### Define a static well-known agent with authentication

Source: https://rockbot.dev/a2a.html

Include authHeaderName and authHeaderValueBase64 fields to support agents requiring API key authentication.

```json
[
  {
    "agentName": "Bob",
    "url": "http://gateway-bob:5200",
    "authHeaderName": "X-Api-Key",
    "authHeaderValueBase64": "YWxpY2UtY2FsbHMtYm9i"
  }
]
```

--------------------------------

### Customize Agent Configuration

Source: https://rockbot.dev/getting-started-docker-desktop.html

Commands to locate the agent data volume or inject custom configuration files into the running container.

```bash
# Find the volume mount path
docker volume inspect <your-directory>_agent-data

# Or copy a file into the running container
docker compose cp my-custom-soul.md agent:/data/agent/soul.md
```

--------------------------------

### Create a morning briefing task

Source: https://rockbot.dev/getting-started-rockbot.html

Request a recurring weekday morning briefing task.

```text
Create a weekday 7:30 AM scheduled task called morning-briefing that checks my calendar, recent messages, and any urgent follow-ups, then gives me a concise morning briefing.
```

--------------------------------

### Locate Docker Compose files

Source: https://rockbot.dev/getting-started-docker-desktop.html

The directory structure for the Docker Compose template and environment configuration.

```text
deploy/docker-compose/
  docker-compose.yml   # RabbitMQ + Agent + Blazor UI
  .env.example         # Template for your API keys
```
Tokens:
Raw