site.yaml

site:
  name: "Codebolt"
  logo:
    text: "Code"
    highlight: "bolt"

navigation:
  navbar:
    links:
      - label: "Features"
        href: "/engine"
        children:
          - { label: "Engine Overview", href: "/engine" }
          - { label: "System Extensibility", href: "/engine/system-extensibility" }
          - { label: "Agent Extensibility", href: "/engine/agent-extensibility" }
          - { label: "Dynamic Evolving Memory", href: "/engine/dynamic-scalable-evolving-memory" }
          - { label: "Multi-Agent Scaling", href: "/engine/multi-agent" }
          - { label: "Multi-Environment Scaling", href: "/engine/multi-environment" }
          - { label: "Agent Orchestration", href: "/engine/agent-orchestration" }
          - { label: "Codebolt Native Applications", href: "/engine/codebolt-native-applications" }
      - label: "Products"
        href: "/products/editor"
        children:
          - { label: "Codebolt Editor", href: "/products/editor" }
          - { label: "Codebolt CLI", href: "/products/cli" }
          - { label: "Codebolt Cloud", href: "/products/cloud" }
          - { label: "Codebolt 24/7 Autonomous Agent", href: "/products/autonomous-agent" }
          - { label: "Codebolt SDK", href: "/products/sdk" }
      - label: "Use Cases"
        href: "/use-cases"
        children:
          - { label: "Overview", href: "/use-cases" }
          - { label: "Custom Agent Development", href: "/use-cases/custom-agent-development" }
          - { label: "Autonomous Companies", href: "/use-cases/autonomous-companies" }
          - { label: "Coding Agent", href: "/use-cases/coding-agent" }
          - { label: "Agent Cloud", href: "/use-cases/agent-cloud" }
      - { label: "Architecture", href: "/architecture" }
      - { label: "Pricing", href: "/pricing" }
      - { label: "Docs", href: "https://docs.codebolt.ai", external: true }
    cta:
      - { label: "Download", href: "/download", variant: "secondary" }
      - { label: "Login", href: "https://portal.codebolt.ai", variant: "primary", external: true }
  footer:
    brand:
      tagline: "One engine. Every scale."
    columns:
      - heading: "Product"
        links:
          - { label: "Engine", href: "/engine" }
          - { label: "System Extensibility", href: "/engine/system-extensibility" }
          - { label: "Agent Extensibility", href: "/engine/agent-extensibility" }
          - { label: "Dynamic Evolving Memory", href: "/engine/dynamic-scalable-evolving-memory" }
          - { label: "Multi-Agent Scaling", href: "/engine/multi-agent" }
          - { label: "Multi-Environment Scaling", href: "/engine/multi-environment" }
          - { label: "Agent Orchestration", href: "/engine/agent-orchestration" }
          - { label: "Codebolt Native Applications", href: "/engine/codebolt-native-applications" }
          - { label: "Codebolt Editor", href: "/products/editor" }
          - { label: "Codebolt CLI", href: "/products/cli" }
          - { label: "Codebolt Cloud", href: "/products/cloud" }
          - { label: "Codebolt 24/7 Autonomous Agent", href: "/products/autonomous-agent" }
          - { label: "Codebolt SDK", href: "/products/sdk" }
          - { label: "Use Cases", href: "/use-cases" }
          - { label: "Custom Agent Development", href: "/use-cases/custom-agent-development" }
          - { label: "Autonomous Companies", href: "/use-cases/autonomous-companies" }
          - { label: "Coding Agent", href: "/use-cases/coding-agent" }
          - { label: "Agent Cloud", href: "/use-cases/agent-cloud" }
          - { label: "Architecture", href: "/architecture" }
          - { label: "Pricing", href: "/pricing" }
          - { label: "Changelog", href: "/changelog" }
      - heading: "Resources"
        links:
          - { label: "Docs", href: "https://docs.codebolt.ai", external: true }
          - { label: "Blog", href: "/blog" }
          - { label: "GitHub", href: "https://github.com/codebolt", external: true }
      - heading: "Company"
        links:
          - { label: "About", href: "/about" }
          - { label: "Careers", href: "/careers" }
          - { label: "Contact", href: "mailto:contact@codebolt.ai" }
    bottom:
      copyright: "2026 Codebolt"
      links:
        - { label: "Privacy", href: "/privacy" }
        - { label: "Terms", href: "/terms" }

# ─────────────────────────────────────────────
# PAGES
# ─────────────────────────────────────────────

pages:

  # ── Homepage ────────────────────────────────
  - slug: ""
    title: "Codebolt — AI Engine for Agent-Native Software"
    navbar_variant: "transparent"
    sections:

      - type: hero
        eyebrow: "AGENT-NATIVE SOFTWARE"
        heading: "The self-evolving, swarm-scale AI orchestration engine"
        headingAccent:
          - "self-evolving"
          - "swarm-scale"
        subheading: "Build software with Codebolt. Run and coordinate hundreds of autonomous agents across laptops, cloud, and fleets. Ship Codebolt-native applications that run directly on the engine runtime."
        buttons:
          - { label: "Download", href: "/download", variant: "primary" }
          - { label: "Read the Docs", href: "/docs", variant: "secondary" }
      - type: start-tabs
        eyebrow: "Use Codebolt where you work"
        tabs:
          - label: "CLI"
            body: "Install globally with npm. Run in your terminal. Use a built-in agent or write your own — full SDK access, any LLM provider."
            code: "npm i -g codebolt"
            primary: { label: "Install Guide", href: "/products/cli" }
            more: { label: "View CLI", href: "/products/cli" }
            media:
              label: "~ codebolt"
              src: "/images/cli-1.gif"
              alt: "Codebolt CLI terminal interface"
              placeholder: "CLI Terminal"
          - label: "Editor"
            body: "Polished desktop IDE with the engine running locally. Monaco editor, agent workspace, plugin panel. Available for macOS, Windows, and Linux."
            primary: { label: "Download Editor", href: "/download" }
            more: { label: "View Editor", href: "/products/editor" }
            media:
              label: "Codebolt Editor"
              src: "/images/desktop.png"
              alt: "Codebolt desktop editor interface"
              placeholder: "Desktop IDE"
          - label: "Cloud"
            body: "Hosted engine in your browser. No install. Spawn workspaces, run agents on managed sandboxes, share state with your team."
            primary: { label: "Open Cloud", href: "https://cloud.codebolt.ai" }
            more: { label: "View Cloud", href: "/products/cloud" }
            media:
              label: "Remote Chat"
              src: "/images-withoutbackground/cloud.png"
              alt: "Codebolt remote chat workspace showing a live autonomous agent completing build and server tasks"
              placeholder: "Browser Workspace"
          - label: "SDK"
            body: "Embed the engine in your own product. Agent SDK (63+ modules), Plugin SDK (3 channels), Client SDK (72 REST + 33 WS). Self-host the engine or call it as a service."
            primary: { label: "Get the SDK", href: "/products/sdk" }
            more: { label: "View SDK", href: "/products/sdk" }
            media:
              label: "codeboltjs"
              src: "/images/sdk-editor.png"
              alt: "Codebolt Agent SDK TypeScript editor example"
              placeholder: "Engine, embedded"

      - type: highlight-banner
        tone: "accent"
        content: |
          Start like Claude Code. Scale like nothing else exists. <span class="text-primary">One engine. Every scale.</span>

      - type: stat-grid
        tone: "muted"
        columns: 3
        stats:
          - { label: "SDK Modules", value: "63+" }
          - { label: "LLM Providers", value: "17+" }
          - { label: "Communication Channels", value: "3" }
          - { label: "Environments", value: "Unlimited" }

      - type: centered-text
        variant: "thesis"
        text: "Claude Code is an agent. OpenClaw is an assistant. Cursor is an editor. Codebolt is the engine that can become any of them — and scale beyond all of them."

      # ── What is Agent-Native Software? ──
      - type: icon-grid
        tone: "muted"
        kicker: "WHAT IS AGENT-NATIVE SOFTWARE"
        title: |
          Software that runs itself, improves itself,
          distributes itself, and composes with other software like it.
        description: "Agent-native software has properties traditional software doesn't. Codebolt is the engine that makes them possible."
        columns: 5
        features:
          - icon: "zap"
            title: "Runs itself"
            description: "Autonomous loops, hooks, schedules, webhooks. The agent stays in motion without you driving it. You don't have to be in the loop for work to happen."
          - icon: "git-branch"
            title: "Improves itself"
            description: "Define what good looks like with eval tasks. The optimizer iterates on prompts, tools, and configs across runs. Your agents get measurably better with use, not worse."
          - icon: "layers"
            title: "Distributes itself"
            description: "Lives where customers already are — Slack, Telegram, Discord, email, web. The Routing Gateway carries the same agent to every surface, no glue code."
          - icon: "cpu"
            title: "Composes"
            description: "Agents call agents. Multi-agent by default. Stigmergy, deliberation councils, review-merge — coordination is built in, not bolted on."

      # ── What you can build / run ─────────────────
      - type: section-header
        kicker: "WHAT YOU CAN BUILD"
        kickerDot: "primary"
        align: "center"
        title: "Four things you do on the engine"
        description: "Build software. Build a custom harness. Run autonomous. Build on top — the same engine covers the full arc, from your first agent to applications that run on top of Codebolt."

      - type: feature-block
        kicker: "01 · BUILD WITH CODEBOLT"
        heading: "Build software (and more) with Codebolt"
        body: "Use the <a class='inline-tag' href='/products/editor'>Editor</a>, <a class='inline-tag' href='/products/cli'>CLI</a>, or terminal as a coding partner — like Claude Code, but with <a class='inline-tag' href='/products/sdk'>custom agents</a>, any LLM, and full SDK access. Then push beyond software: spin up agents that draft documents, edit videos, run research, generate decks. Anything an agent can do, you can build a workflow for."
        cta: { label: "See the products", href: "/products/editor" }
        image: "/images/desktop.png"
        imageAlt: "Codebolt workspace connecting editor, CLI, agents, project context, and memory"

      - type: feature-block
        kicker: "02 · BUILD YOUR HARNESS"
        heading: "Build your custom harness"
        body: "Don't settle for someone else's agent loop. Write <a class='inline-tag' href='/products/sdk'>custom agents</a> in JavaScript with the 63-module SDK — full control over prompts, tools, memory, and routing. Build <a class='inline-tag' href='/engine/system-extensibility'>custom plugins</a> that run inside the engine on three communication channels. Or ship <a class='inline-tag' href='/products/sdk'>custom UIs</a> on top of the Client SDK. Your agents, your tools, your rules."
        reverse: true
        cta: { label: "Explore Agent + Plugin SDKs", href: "/products/sdk" }
        image: "/images/sdk-code-diagram.svg"
        imageAlt: "Codebolt Agent SDK code snippet showing a 10-line custom agent with LLM, filesystem, and git modules"

      # ── BENTO EXPERIMENT (Build harness variant) ──
      - type: bento-grid
        kicker: "BENTO VARIANT · BUILD HARNESS"
        heading: "Build your custom harness"
        description: "Same content as the section above, in a bento grid layout. Compare and pick the one you like."
        columns: 3
        gap: "none"
        items:
          - title: "Custom Agents"
            tag: "AGENT SDK"
            description: "Write agents in JavaScript with 63+ SDK modules. Full control over the agentic loop — prompts, tools, memory, routing."
            href: "/products/sdk"
            span: 2
            image:
              src: "/images/sdk-agent-layer.svg"
              alt: "Agent SDK layer with prompts, tools, memory, browser, filesystem, and git modules"
          - title: "Custom Plugins"
            tag: "PLUGIN SDK"
            description: "Run inside the engine on three channels — WebSocket actions, multiplexed events, HTTP REST."
            href: "/engine/system-extensibility"
            span: 1
            image:
              src: "/images/sdk-plugin-layer.svg"
              alt: "Plugin SDK layer with WebSocket, multiplexed event, and HTTP channels"
          - title: "Remix Agents"
            tag: "NO-CODE"
            description: "Inherit a base agent. Customize in YAML + Markdown. Git-friendly. No code required."
            span: 1
            image:
              src: "/images/remix.png"
              alt: "Agent framework options for remix, flow, and custom agents"
          - title: "Flow Agents"
            tag: "VISUAL"
            description: "Drag-and-drop agent workflows. LiteGraph editor. Compose agents with no code."
            span: 1
            image:
              src: "/images/agentflow.png"
              alt: "Visual flow agents moving through plan, edit, test, and review stages"
          - title: "Custom UI"
            tag: "CLIENT SDK"
            description: "Build dashboards, panels, mobile apps. 72 REST + 33 WebSocket modules."
            href: "/products/sdk"
            span: 1
            image:
              src: "/images/customuis.png"
              alt: "Client SDK interface with REST, WebSocket, dashboard, panel, and mobile surfaces"

      - type: feature-block
        kicker: "03 · RUN AUTONOMOUS"
        heading: "Run an autonomous organization"
        body: "Promote your agents to always-on. The <a class='inline-tag' href='/products/autonomous-agent'>24/7 Autonomous Agent</a> runs locally or on <a class='inline-tag' href='/products/cloud'>Codebolt Cloud</a> — proactive scheduling, persistent memory, plugin integrations to the messengers and APIs your business already uses. From one always-on assistant to a full <a class='inline-tag' href='/use-cases/autonomous-companies'>autonomous company</a> with agents managing engineering, QA, deployment, and monitoring as plugins."
        cta: { label: "See the autonomous agent", href: "/products/autonomous-agent" }
        image: "/images/autonomous-scale.svg"
        imageAlt: "Always-on autonomous organization with persistent memory, schedules, hooks, webhooks, plugins, and scaling"

      - type: feature-block
        kicker: "04 · BUILD ON TOP"
        heading: "Build on top of Codebolt"
        body: "The engine is a substrate, not a destination. Ship <a class='inline-tag' href='/engine/system-extensibility'>custom applications as plugins</a> that ride inside the engine — they get memory, scheduling, multi-agent coordination, and routing for free. Or build <a class='inline-tag' href='/products/cloud'>cloud-native apps</a> on Codebolt Cloud that share the same workspaces, sandboxes, and agent runtime your team already uses."
        reverse: true
        cta: { label: "Explore the Cloud", href: "/products/cloud" }
        image: "/images/sdk-native-application.svg"
        imageAlt: "Codebolt-native application with plugin backend, dynamic panel frontend, agents, tools, memory, and project state"

      # ── ACCORDION EXPERIMENT (Build on top variant) ──
      - type: feature-accordion
        kicker: "ACCORDION VARIANT · BUILD ON TOP"
        heading: "Build on top of Codebolt"
        description: "Same content as the section above, in an accordion-with-visual layout. Click any row to swap the panel."
        items:
          - title: "Custom Plugins"
            icon: "PLG"
            description: "Ship your application as a plugin that runs inside the engine. Get memory, scheduling, multi-agent coordination, and routing for free."
            href: "/engine/system-extensibility"
            image:
              src: "/images/sdk-plugin-runtime.svg"
              alt: "Plugin runtime connected to engine memory, scheduling, coordination, and routing"
          - title: "Cloud-Native Apps"
            icon: "CLD"
            description: "Build apps on Codebolt Cloud that share the same workspaces, sandboxes, and agent runtime your team already uses."
            href: "/products/cloud"
            image:
              src: "/images/cloud-app-backends.svg"
              alt: "Cloud-native app backends using browser portal, managed sandboxes, shared workspaces, and hosted agent runtime"
          - title: "Vertical IDEs"
            icon: "IDE"
            description: "Compose panels and plugins into a domain-specific IDE — your customers see your surface, not Codebolt's."
            image:
              src: "/images/editor-runtime-panels.svg"
              alt: "Vertical IDE composed from editor panels, custom tools, terminal, and plugins"
          - title: "Domain Workflows"
            icon: "WF "
            description: "Package compliance, sales, ops, or any vertical workflow as a plugin. Agents pick it up automatically."
            image:
              src: "/images/autonomous-hooks.svg"
              alt: "Domain workflow with triggers, policy, logging, agent handoff, and plugin execution"
          - title: "Developer Tools"
            icon: "DEV"
            description: "Ship review, deploy, monitor, lint, or any developer-facing tool as a plugin on the engine."
            image:
              src: "/images/cloud-operations.svg"
              alt: "Developer tool plugin for review, deploy, lint, monitor, test, and audit workflows"

      # ── Why it's different ──────────────────────
      - type: section-header
        kicker: "WHY IT'S DIFFERENT"
        kickerDot: "primary"
        align: "center"
        title: "Two properties no other agent tool has"
        description: "Self-Improving by design. Hyper-Scaling by architecture. Most agent tools get worse with use and stop at a single environment — Codebolt's engine gets measurably better and scales to 100+ agents across machines."

      - type: feature-block
        kicker: "05 · SELF-IMPROVING"
        heading: "Self-Improving by design"
        body: "Define what good looks like with <a class='inline-tag' href='/architecture'>eval tasks</a>. The optimizer iterates on prompts, tools, and configs across runs and keeps the winners. <a class='inline-tag' href='/architecture'>Three-tier memory</a> compounds knowledge across sessions — episodic, persistent, and a context-assembly engine that decides what each agent sees. The engine even generates new <a class='inline-tag' href='/products/sdk'>agents and plugins</a> dynamically when the work calls for it. Agents get measurably better with use, not worse."
        cta: { label: "Read the architecture", href: "/architecture" }
        image: "/images/editor-lifecycle-quality.svg"
        imageAlt: "Evaluation and optimization loop with scoring, prompt and tool updates, memory evolution, and dynamic generation"

      - type: feature-block
        kicker: "06 · HYPER-SCALING"
        heading: "Hyper-Scaling by architecture"
        body: "One agent in your terminal is the same engine that coordinates 100+ agents across <a class='inline-tag' href='/engine/multi-environment'>local, Docker, and cloud</a>. Proxy execution chains environments — Env A → B → C, any topology. <a class='inline-tag' href='/engine/multi-agent'>Stigmergy</a> gives you bio-inspired coordination: pheromone task ownership, deliberation councils, automatic review and merge — no GitHub-PR bottleneck. Coordination is built in, not bolted on."
        reverse: true
        cta: { label: "See multi-agent + multi-environment", href: "/engine/multi-environment" }
        image: "/images/cloud-scale-handoff.svg"
        imageAlt: "Multi-environment scaling from local to Docker to cloud with coordination, review, and shared state"

      # ── Scale Spectrum ──
      - type: progression-strip
        kicker: "THE SCALE SPECTRUM"
        heading: "One Engine. Every Scale."
        description: "The same engine powers every level. Start anywhere. Scale without rebuilding."
        steps:
          - label: "CLI"
            description: "A coding agent in your terminal. One agent, full SDK."
            reference: "Like Claude Code"
          - label: "Editor"
            description: "Desktop editor with agent workspace and plugin panel."
            reference: "Like Cursor"
          - label: "24/7 Agent"
            description: "Always-on agent with persistent memory and plugin integrations."
            reference: "Like OpenClaw / Hermes"
          - label: "Orchestration"
            description: "50-100+ agents coordinated across environments."
            reference: "Beyond any single tool"
          - label: "Autonomous Company"
            description: "Business domains as plugins. Agents coordinate across all of them."
            reference: "Like Paperclip, but built-in"

      # ── Codebolt Surfaces (Showcase Strip) ──
      - type: showcase-strip
        kicker: "ENGINE · SURFACES"
        heading: "One engine. Every surface."
        subtitle: "Same engine, same SDK, same plugins — different interface for different needs."
        columns: 4
        items:
          - title: "CLI"
            description: "Terminal client. Like Claude Code, but with custom agents and a growth path to multi-agent."
            href: "/products/cli"
            image:
              src: "/images/cli-feature.gif"
              alt: "CLI agent conversations with terminal prompts, custom agents, server mode, and prompt runs"
          - title: "Editor"
            description: "Desktop editor with Monaco, agent workspace, and plugin panel. Not a fork."
            href: "/products/editor"
            image:
              src: "/images/editor-feature.gif"
              alt: "Editor workspace with project files, agents, terminal, browser, and plugin panels"
          - title: "24/7 Autonomous Agent"
            description: "Always-on agent with persistent memory and plugin integrations. Reaches your customers wherever they are."
            href: "/products/autonomous-agent"
            image:
              src: "/images/autonomous-scale.svg"
              alt: "Always-on autonomous agent with memory, plugins, hooks, external channels, and scaling"
          - title: "Cloud"
            description: "Hosted engine with a browser portal. Sandbox runs, shared workspaces, no install."
            href: "/products/cloud"
            image:
              src: "/images/cloud-feature.gif"
              alt: "Cloud portal with managed sandboxes, browser sessions, shared workspaces, and hosted runtime"

      - type: sdk-callout
        kicker: "BUILD YOUR OWN SURFACE"
        heading: "SDK for products that need the engine inside."
        description: "Use the Agent SDK, Plugin SDK, and Client SDK to embed Codebolt in your own product, ship agent-native apps, or run the engine headless on your infrastructure."
        features:
          - "Agent SDK"
          - "Plugin SDK"
          - "Client SDK"
          - "Self-hosted engine"
        cta: { label: "Explore the SDK", href: "/products/sdk" }

      # ── Engine Pillars (Feature Showcase — Windsurf style) ──
      - type: feature-showcase
        kicker: "THE ENGINE"
        heading: "The pillars of the engine"
        subtitle: "Extensible at every layer. Self-improving by design. Moldable at the surface."
        gap: "none"
        heroFeatures:
          - title: "System Extensibility"
            description: "Three SDKs. Agent SDK (63+ modules), Plugin SDK (3 channels), Client SDK (72 REST + 33 WS). The system is open at every layer."
            href: "/engine/system-extensibility"
            tag: "EXTEND THE SYSTEM"
            image:
              src: "/images/sdk-agent-layer.svg"
              alt: "System extensibility through Agent SDK, Plugin SDK, and Client SDK layers"
          - title: "Agent Extensibility"
            description: "Remix agents (no-code YAML), Flow agents (visual graph), Custom agents (full code). 675+ skills across 72 domains. Role-specific LLM configs."
            href: "/engine/agent-extensibility"
            tag: "EXTEND ANY AGENT"
            image:
              src: "/images/sdk-agent-framework.svg"
              alt: "Agent extensibility through remix agents, flow agents, custom agents, skills, and role model configs"
          - title: "Self-Improving by Design"
            description: "Define what good looks like with eval tasks. The optimizer iterates on prompts, tools, and configs across runs. Your agents get measurably better with use, not worse."
            tag: "EVAL · OPTIMIZE"
            image:
              src: "/images/editor-lifecycle-quality.svg"
              alt: "Self-improving loop with eval tasks, scoring, optimizer updates, reruns, and retained winners"
        compactFeatures:
          - title: "Dynamic Interface Generation"
            description: "Panels and plugins compose into the surface your customers see. Ship a vertical IDE, a domain-specific UI, or a SaaS — assembled from the engine's parts."
            tag: "MOLDABLE"
          - title: "Multi-Agent Scaling"
            description: "Sub-agents, parallel execution, stigmergy coordination, pheromone ownership, deliberation councils, auto review & merge — within one environment."
            href: "/engine/multi-agent"
            tag: "COORDINATION"
          - title: "Multi-Environment Scaling"
            description: "Proxy execution chains environments. Env A → B → C. Any topology. Git bundle state transfer."
            href: "/engine/multi-environment"
            tag: "ACROSS MACHINES"
          - title: "Narrative Engine"
            description: "Rust-based flight recorder. Shadow git snapshots. Per-thread history. Deterministic replay."
            tag: "RUST"
          - title: "Guardrails"
            description: "Policy engine with LLM risk classification. Per-role, per-environment, per-phase. Allow, deny, escalate."
            tag: "GOVERNANCE"
          - title: "Three-Tier Memory"
            description: "Episodic + Persistent + Context Assembly Engine. Token budgets. Agents know what to remember."
            tag: "MEMORY"

      - type: quote-block
        variant: "muted"
        align: "center"
        quote: "The same engine that powers a simple coding CLI also powers a 100-agent autonomous company. Everything you build — agents, plugins, memory, workflows — carries forward as you scale."
        attribution: "Codebolt Engineering"

      # ── About the Engine (Bento Grid) ──
      - type: bento-grid
        kicker: "ABOUT THE ENGINE"
        heading: "Built different. Scales different."
        description: "An advanced agent execution engine — from one agent to autonomous companies."
        columns: 3
        gap: "none"
        items:
          - title: "63+ SDK Modules"
            description: "Filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graph, code search, and more."
            tag: "AGENT SDK"
            span: 1
            image:
              src: "/images/sdk-agent-layer.svg"
              alt: "Agent SDK module layer for filesystem, git, browser, terminal, LLM, vector database, memory, and agents"
          - title: "3 Communication Channels"
            description: "Agent channel for work. Plugin channel for extensions. Client channel for interfaces. Each serves a distinct purpose."
            tag: "ARCHITECTURE"
            span: 2
            image:
              src: "/images/sdk-client-layer.svg"
              alt: "Three communication channels for agent work, plugin extensions, and client interfaces"
          - title: "17+ LLM Providers"
            description: "OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, Ollama, LM Studio. Per-agent, per-task model selection."
            tag: "MODEL AGNOSTIC"
            span: 1
            image:
              src: "/images/sdk-provider-layer.svg"
              alt: "Model provider layer spanning OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, Ollama, and local providers"
          - title: "Multi-Environment"
            description: "Local, Docker, cloud, hierarchical. Proxy execution chains them together. Git bundles transfer state."
            tag: "INFRASTRUCTURE"
            span: 1
            image:
              src: "/images/cloud-scale-handoff.svg"
              alt: "Multi-environment scale handoff from local to Docker to cloud and hierarchical infrastructure"
          - title: "Stigmergy + Deliberation"
            description: "Bio-inspired coordination. Pheromone task ownership. Agent deliberation councils. Review & merge without GitHub PR bottleneck."
            tag: "COORDINATION"
            span: 1
            image:
              src: "/images/cli-orchestration-map.svg"
              alt: "Stigmergy and deliberation coordination map with shared state, ownership, consensus, and auto merge"

      - type: comparison-columns
        problem:
          heading: "Other tools"
          items:
            - "Claude Code — great CLI agent, but you can't customize the loop or scale beyond one agent"
            - "Cursor — great IDE, but agents are fixed and there's no plugin system"
            - "OpenClaw — great personal agent, but no multi-agent coordination or enterprise scaling"
            - "LangChain/CrewAI — agent frameworks, but no execution environment"
            - "Each tool is one thing. If you outgrow it, you start over."
        solution:
          heading: "Codebolt"
          items:
            - "One engine that starts as a CLI and scales to orchestrate 100+ agents"
            - "Full control over the agentic loop — write agents in code, not prompts"
            - "Plugin system with 3 communication channels — plugins run inside the platform"
            - "Multi-environment scaling across local, Docker, cloud, and hierarchical setups"
            - "Everything carries forward. Agents, plugins, memory, workflows — nothing gets rebuilt."

      # ── Competitive Landscape ──
      - type: comparison-table
        kicker: "COMPETITIVE LANDSCAPE"
        heading: "How Codebolt compares"
        description: "Every tool does one thing. Codebolt is the engine that does all of them."
        highlightColumn: 1
        columns:
          - "Capability"
          - "Codebolt"
          - "Claude Code"
          - "OpenClaw"
          - "Paperclip"
          - "Hermes"
          - "Letta"
          - "Cursor"
        rows:
          - label: "What it is"
            values:
              - "Agent engine (CLI → autonomous company)"
              - "CLI coding agent"
              - "Personal AI assistant"
              - "Company orchestrator (manages agents, doesn't run them)"
              - "Self-improving agent framework"
              - "Stateful agent platform"
              - "AI-enhanced IDE"
          - label: "Runs agents"
            values: ["Yes — custom agents via 63-module SDK", "Built-in only", "Built-in only", "No — orchestrates external agents", "Yes — function-calling", "Yes — stateful agents", "Built-in only"]
          - label: "Multi-agent orchestration"
            values: ["Yes — stigmergy, deliberation, 100+ agents", "No", "No", "Yes — org charts, roles, budgets", "No", "Limited", "No"]
          - label: "Scales to"
            values: ["1 to 100+ agents, multi-environment", "1 agent", "1 agent", "Depends on agents you bring", "1 agent (subagents)", "1-10 agents", "1 agent"]
          - label: "Memory system"
            values: ["3-tier (episodic, persistent, context assembly)", "Session only", "Persistent", "None", "Persistent + learning loop", "Persistent (core feature)", "Session only"]
          - label: "Plugin system"
            values: ["Yes — 3 channels (WS, Mux, HTTP)", "Skills (limited)", "Skills/integrations", "Agent adapters", "Skills (agentskills.io)", "No", "VS Code extensions"]
          - label: "Surfaces"
            values: ["CLI + Editor + TUI + Cloud + headless", "CLI + IDE extensions", "Web + chat apps", "Web dashboard", "CLI + chat apps", "CLI + API", "IDE only"]
          - label: "Self-improving"
            values: ["Yes — memory compounds, context optimizes", "No", "Yes — writes own skills", "No", "Yes — learning loop", "Yes — background subagents", "No"]

      - type: icon-grid
        tone: "muted"
        kicker: "ENGINE CAPABILITIES"
        title: |
          What makes the engine powerful
          63+ modules. 3 channels. Unlimited scale.
        description: "Every capability is available at every scale — from CLI to autonomous company."
        columns: 3
        features:
          - icon: "layers"
            title: "63+ SDK Modules"
            description: "Filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graph, code search, and more."
          - icon: "cpu"
            title: "3 Communication Channels"
            description: "Agent channel (codeboltjs), Plugin channel (WS + HTTP), Client channel (UI/TUI/Web). Each serves a purpose."
          - icon: "git-branch"
            title: "Multi-Environment"
            description: "Local, Docker, cloud, hierarchical. State transfer via git bundles. Heartbeat monitoring. Full lifecycle management."
          - icon: "shield"
            title: "Guardrails & Governance"
            description: "Policy engine with LLM risk classification. Per-agent, per-environment, per-phase scoping. Allow, deny, or escalate."
          - icon: "code"
            title: "17+ LLM Providers"
            description: "OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, Ollama, LM Studio. Per-agent, per-task model selection."
          - icon: "zap"
            title: "Built-in Review & Merge"
            description: "Agents review each other's work. Conflict detection. Pheromone coordination. No GitHub PR bottleneck."

      # ── Reach Everywhere ──
      - type: connectivity-grid
        kicker: "REACH"
        heading: "Reachable from everywhere"
        description: "The engine connects to your entire workflow through its plugin system. Native interfaces plus anything plugins can reach."
        columns: 4
        items:
          - { label: "Terminal / CLI", category: "interface" }
          - { label: "Desktop IDE", category: "interface" }
          - { label: "Web UI", category: "interface" }
          - { label: "TUI", category: "interface" }
          - { label: "WhatsApp", category: "messaging" }
          - { label: "Telegram", category: "messaging" }
          - { label: "Slack", category: "messaging" }
          - { label: "Discord", category: "messaging" }
          - { label: "Email", category: "communication" }
          - { label: "Webhooks", category: "automation" }
          - { label: "CI/CD Pipelines", category: "automation" }
          - { label: "REST API", category: "automation" }

      # ── Grows With You ──
      - type: quote-block
        variant: "muted"
        align: "center"
        quote: "The engine doesn't just run agents — it learns. Three-tier memory compounds knowledge across sessions. Skills improve through use. Context assembly optimizes what each agent sees. The longer you run Codebolt, the smarter it gets."
        attribution: "Codebolt Engineering"

      - type: card-grid
        heading: "The Progression"
        gap: "none"
        cards:
          - title: "Day 1 — CLI in your terminal"
            body: "Install Codebolt. Run it in your terminal. Use a built-in agent or bring your own. Like Claude Code but with any model, full SDK access, and room to grow."
            image:
              src: "/images/cli-agent-conversations.svg"
              alt: "Day one CLI session starting Codebolt in the terminal with agent conversations"
          - title: "Week 2 — Custom Agents"
            body: "Write your first agent in 10 lines of JavaScript. Full access to 63+ SDK modules. Your logic, your tools, your rules. No other tool gives you this for free."
            image:
              src: "/images/sdk-agent-flow.svg"
              alt: "Custom agent flow using SDK modules, prompts, tools, memory, and routing"
          - title: "Month 2 — Editor + Plugins"
            body: "Switch to the desktop Editor. Install plugins that connect to GitHub, Jira, Slack. Build custom plugins. Multiple agents coordinating on your codebase."
            image:
              src: "/images/editor-project-workspace.svg"
              alt: "Editor workspace with Monaco, plugins, terminal, browser, agents, and project files"
          - title: "Month 6 — 24/7 Autonomous Agent"
            body: "Your agent runs always-on. Persistent memory. Proactive scheduling. Plugin integrations handle email, calendar, monitoring. Like OpenClaw, but on an engine that scales."
            image:
              src: "/images/autonomous-schedule.svg"
              alt: "Always-on autonomous agent schedule with persistent memory and proactive plugin integrations"
          - title: "Year 1 — Orchestration"
            body: "50+ agents across Docker and cloud environments. Stigmergy coordination. Deliberation councils. Automatic review and merge. Drift tracking. Your infrastructure, not your bottleneck."
            image:
              src: "/images/cloud-scale-handoff.svg"
              alt: "Orchestration across local, Docker, and cloud environments with review and shared state"
          - title: "Year 2 — Autonomous Company"
            body: "Applications run as plugins inside the engine. Each handles a domain — engineering, testing, deployment, monitoring. Agents coordinate across all of them. You direct the vision."
            image:
              src: "/images/autonomous-scale.svg"
              alt: "Autonomous company with business domains as plugins and agents coordinating across them"

      - type: persona-grid
        personas:
          - label: "Solo Developers"
            body: "Start with the CLI. Use one agent. Write custom agents when you're ready. More power than any free coding tool — because you control the agent, not just the prompt."
          - label: "Teams Scaling AI"
            body: "When two agents edit the same repo, the platform resolves conflicts. Coordination, drift tracking, and multi-environment management — so you focus on the product."
          - label: "AI Startup Founders"
            body: "Build your company on the engine. Applications run as plugins — no separate agent instances needed. Scale across environments as you grow."
          - label: "Enterprise & Production"
            body: "Governance, audit trails, deterministic replay, and guardrails. Every agent decision is traceable. Every change is attributable. Deploy agents in production with confidence."
          - label: "Platform Engineers"
            body: "Run headless in CI/CD. Spawn Docker environments. Transfer state between them. Monitor with real-time events. The engine was built for infrastructure people."
          - label: "AI Researchers"
            body: "Stigmergy-based coordination. Pheromone systems. Narrative versioning. Agent deliberation councils. Research-grounded architecture with published foundations."

      - type: cta-block
        heading: "One engine. Start simple. Scale without limits."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Engine ─────────────────────────────────
  # ── Engine Overview ─────────────────────────
  - slug: "engine"
    title: "The Engine — Codebolt"
    sections:

      - type: page-header
        title: "The Codebolt Engine"
        subtitle: "An advanced agent execution engine. As simple as a coding CLI. As powerful as autonomous company infrastructure."

      - type: centered-text
        variant: "thesis"
        text: "Codebolt is not an agent — it's the engine that runs agents. Not a framework — it's the execution environment where agents, plugins, and applications operate. Every other tool is one thing. Codebolt is the engine that becomes what you need."

      - type: engine-architecture-diagram
        kicker: "TOPOLOGY"
        heading: "Engine + Channels + Interfaces"
        description: "Agents connect through the Agent SDK. Plugins extend through the Plugin SDK. Interfaces connect through the Client SDK. All three channels meet at the engine core."

      - type: diagram-section
        heading: "Engine Architecture"
        layers:
          - { label: "Interface Layer — IDE, TUI, CLI, Web", tag: "surface", style: "surface" }
          - { label: "Communication Layer — Agent SDK, Plugin SDK, Client SDK", tag: "runtime", style: "runtime" }
          - { label: "Coordination Layer — Stigmergy, Deliberation, Pheromones", tag: "coordination", style: "drift" }
          - { label: "Intelligence Layer — Drift Engine, Narrative Versioning (Rust)", tag: "intelligence", style: "versioning" }
          - { label: "Infrastructure Layer — Governance, Environments, Providers", tag: "core", style: "governance" }
        annotation: "Other tools operate at Layer 1-2. Agent frameworks at Layer 2. Codebolt is all five layers — a complete engine."

      # ── Four Pillars Overview ──
      - type: card-grid
        heading: "Four Pillars of the Engine"
        columns: 2
        cards:
          - title: "System Extensibility"
            body: "Extend the engine itself. Write custom agents with the 63-module SDK. Build plugins with 3 communication channels. Create custom clients with 72 REST APIs + 33 WebSocket modules. The system is open at every layer."
            href: "/engine/system-extensibility"
          - title: "Agent Extensibility"
            body: "Make any agent more powerful. Remix agents inherit and customize without code. Add skills from 675+ tools. Flow-based visual composition. Role-specific LLM configs. Capability declarations. Every agent is extensible."
            href: "/engine/agent-extensibility"
          - title: "Multi-Agent Scaling"
            body: "Within a single environment, agents spawn sub-agents, run parallel child threads, coordinate via stigmergy and pheromones, hold deliberation councils, and review each other's work. From 1 to 100+ agents."
            href: "/engine/multi-agent"
          - title: "Multi-Environment Scaling"
            body: "Across machines: proxy execution chains environments together. Env A calls Env B calls Env C. Providers bridge via WebSocket. Git bundles transfer state. Heartbeat monitoring. Hierarchical or peer-to-peer."
            href: "/engine/multi-environment"

      # ── System Extensibility Preview ──
      - type: section-header
        kicker: "SYSTEM EXTENSIBILITY"
        kickerDot: "primary"
        title: |
          Open at every layer
          Agents, Plugins, Clients — all extensible
        description: "Three SDKs. Three extension points. Complete control over the engine."

      - type: three-column-grid
        divider: true
        columnsHtml:
          - |
            <div class="p-8 md:p-12">
              <div class="text-[10px] font-mono uppercase tracking-widest text-muted-foreground mb-4">AGENT SDK</div>
              <h3 class="text-xl font-medium text-foreground mb-3 tracking-tight">Custom Agents</h3>
              <p class="text-sm text-muted-foreground leading-relaxed">Write agents in JavaScript with 63+ SDK modules — filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graphs. Full control over the agentic loop.</p>
            </div>
          - |
            <div class="p-8 md:p-12">
              <div class="text-[10px] font-mono uppercase tracking-widest text-muted-foreground mb-4">PLUGIN SDK</div>
              <h3 class="text-xl font-medium text-foreground mb-3 tracking-tight">Custom Plugins</h3>
              <p class="text-sm text-muted-foreground leading-relaxed">Three communication channels — WebSocket actions, multiplexed events, HTTP REST. Plugins run inside the engine. No separate agent instance needed.</p>
            </div>
          - |
            <div class="p-8 md:p-12">
              <div class="text-[10px] font-mono uppercase tracking-widest text-muted-foreground mb-4">CLIENT SDK</div>
              <h3 class="text-xl font-medium text-foreground mb-3 tracking-tight">Custom Clients</h3>
              <p class="text-sm text-muted-foreground leading-relaxed">72 REST API modules + 33 WebSocket modules. Build dashboards, mobile apps, Slack bots, VS Code extensions — anything that talks to the engine.</p>
            </div>

      # ── Agent Extensibility Preview ──
      - type: section-header
        kicker: "AGENT EXTENSIBILITY"
        kickerDot: "emerald"
        title: |
          Every agent is extensible
          Remix, Skills, Flows, Capabilities
        description: "Multiple ways to make agents more powerful — from no-code to full code."

      - type: feature-block
        heading: "Agent Types — From No-Code to Full Code"
        body: "Remix Agents inherit from a base agent and add custom instructions in YAML+Markdown — no code required, git-friendly, composable. Flow Agents use a visual graph editor (LiteGraph) for drag-and-drop agent workflows. Custom Agents are pure code with full SDK access. Remote Agents run in external environments. All types share the same 675+ skill library."
        diagram: |
          Remix Agent (no-code):
          ---
          baseAgent: code-gen
          supportedlanguages: [python]
          ---
          Custom instructions here...

          Flow Agent (visual):
          [Node A] → [Node B] → [Node C]

          Custom Agent (full code):
          codebolt.onMessage(async (msg) => {
            // your logic, your tools
          });

      - type: feature-block
        heading: "675+ Skills Across 72 Domains"
        body: "Agents access skills organized across 72 tool domains — file operations, git, browser control, terminal, LLM, vector database, agent control, memory, knowledge graphs, and more. Skills are scoped by environment capabilities — the engine prevents agents from calling unavailable tools. Add skills, declare capabilities, set per-agent model preferences."
        reverse: true
        diagram: |
          72 tool domains:
          ├─ file (read, write, search, diff)
          ├─ git (commit, push, branch, merge)
          ├─ browser (navigate, click, screenshot)
          ├─ terminal (execute, stream, PTY)
          ├─ llm (chat, embed, count tokens)
          ├─ vectordb (store, query, search)
          ├─ agent (start, stop, list, spawn)
          ├─ memory (persist, retrieve, graph)
          └─ ... 64 more domains
          = 675+ individual tools

      # ── Multi-Agent Preview ──
      - type: section-header
        kicker: "MULTI-AGENT SCALING"
        kickerDot: "amber"
        title: |
          Multiple agents, one environment
          Coordination, not collision
        description: "Sub-agents, parallel execution, stigmergy, deliberation, and review — all within a single Codebolt instance."

      - type: feature-block
        heading: "Sub-Agent Spawning & Parallel Execution"
        body: "An agent can spawn background child threads that run in parallel. Parent agents wait for individual completions, grouped completions, or any external event. Children are full agent instances with complete SDK access — not async tasks. Group multiple children and await batch completion. Message-driven communication between parent and children."
        diagram: |
          Parent Agent
            ├─ spawn → Child 1 (review)
            ├─ spawn → Child 2 (test)
            ├─ spawn → Child 3 (docs)
            │
            └─ waitForGroup('batch-1')
                    ↓
            All children complete
            → Merge results
            → Continue

      - type: feature-block
        heading: "Stigmergy, Deliberation & Auto Review"
        body: "Agents coordinate through shared state (stigmergy), not fragile message passing. Pheromone-based task ownership prevents conflicts. Deliberation councils let agents propose, debate, vote, and reach consensus. The review-merge system lets agents review each other's work and auto-merge without GitHub PR bottleneck. Drift tracking catches deviation across all agents."
        reverse: true
        diagram: |
          Agent A: implements feature
          Agent B: reviews (auto-assigned)
          Agent C: checks for drift
                ↓
          Deliberation if conflict
                ↓
          Auto-merged. Traced. Auditable.
          No human bottleneck.

      # ── Multi-Environment Preview ──
      - type: section-header
        kicker: "MULTI-ENVIRONMENT SCALING"
        kickerDot: "purple"
        title: |
          Chain environments together
          Proxy execution across machines
        description: "One environment's agent can trigger work in another. Chain them. Scale them. Any topology."

      - type: feature-block
        heading: "Proxy Execution — Environment Chaining"
        body: "The RemoteExecutionPlugin bridges environments via WebSocket. Environment A's agent sends work to Environment B, which can forward to Environment C. Any topology — linear chains, trees, peer-to-peer. Each environment runs its own Codebolt instance with full capabilities. The proxy is plugin-based — not hardcoded — so any environment can claim the execution gateway."
        diagram: |
          Env A (laptop)
            │ proxy execution
            ↓
          Env B (Docker GPU)
            │ proxy execution
            ↓
          Env C (cloud cluster)

          Or: Env A ↔ Env B ↔ Env C (peer)
          Or: Env A → [Env B, Env C, Env D] (fan-out)
          Any topology. Plugin-based routing.

      - type: feature-block
        heading: "State Transfer & Lifecycle"
        body: "Git bundles transfer workspace state between environments. The Narrative Engine snapshots per-environment with per-thread git refs. Full lifecycle management — CREATED, STARTING, RUNNING, STOPPING, STOPPED — with heartbeat monitoring every 30 seconds. The provider system treats local, Docker, cloud, and hierarchical environments identically."
        reverse: true
        diagram: |
          Environment Lifecycle:
          CREATED → STARTING → RUNNING
                               ↕ heartbeat (30s)
          STOPPING ← STOPPED ← ERROR

          State Transfer:
          Env A [snapshot] → git bundle
                          → Env B [restore]
          Bidirectional. Any topology.

      # ── Engine Internals ──
      - type: accordion
        heading: "Engine Internals"
        items:
          - question: "Narrative Engine (Rust)"
            answer: "A Rust-based flight recorder capturing the full reasoning chain for every agent action. Shadow git for snapshot versioning. Per-thread commit history. Agent attribution for every change. Git bundle export for cross-environment transfer. Deterministic replay of any decision point. 12 snapshot operations including create, browse, merge, checkout, import/export."
          - question: "Drift Tracking — Two Levels"
            answer: "Local Rust engine instances assess drift within each agent context — structural, scope, constraint, and coverage drift. The global JavaScript coordination layer aggregates signals across all agents, detecting systemic drift that no single agent would catch. When agents deviate from intent, the system flags it before it compounds."
          - question: "Governance & Guardrails"
            answer: "The policy engine evaluates agent actions against configurable rules. Scoped by agent role, agent ID, environment, provider, and execution phase. LLM-based risk classification. Decisions: allow, deny, or escalate to human. Every decision logged for audit."
          - question: "Three-Tier Memory"
            answer: "Episodic memory for time-based recall. Persistent memory with chunking, embedding, and retrieval pipelines. The Context Assembly Engine assembles optimal context from all memory types using rules, pipelines, and token budgets. Agents know what to remember and when."
          - question: "HostBridge Abstraction"
            answer: "The engine never calls platform APIs directly. It defines a HostBridge interface for process spawning, SQLite, Kuzu graph DB, and ONNX inference. Each runtime implements its own bridge: Electron uses UtilityProcess, CLI uses child_process and better-sqlite3, TUI connects via WebSocket proxy. One codebase, every runtime."

      - type: cta-block
        heading: "The engine that scales with your ambition."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Engine: System Extensibility ───────────
  - slug: "engine/system-extensibility"
    title: "System Extensibility — Codebolt"
    sections:

      - type: page-header
        title: "System Extensibility"
        subtitle: "Extend the engine at every layer. Custom agents, custom plugins, custom clients."

      - type: centered-text
        variant: "thesis"
        text: "Most tools give you a prompt box. Codebolt gives you three SDKs. The Agent SDK for building agents. The Plugin SDK for building applications inside the engine. The Client SDK for building any interface on top. Every layer of the system is open."

      - type: feature-block
        heading: "Agent SDK — codeboltjs"
        body: "Write agents in JavaScript/TypeScript. Agents connect as child processes via WebSocket and get access to 63+ API modules — filesystem, git, terminal, browser automation, LLM (any provider), vector database, memory systems, knowledge graphs, code search, and more. You control every step of the agent loop. Not prompts — code."
        diagram: |
          import { codebolt } from 'codeboltjs';

          codebolt.onMessage(async (msg) => {
            const files = await codebolt.fs.readDir('/src');
            const code = await codebolt.fs.readFile('main.ts');
            const review = await codebolt.llm.chat({...});
            await codebolt.git.commit(review.summary);
            await codebolt.chat.sendMessage(review);
          });
          // 63+ modules. Full control.

      - type: feature-block
        heading: "Plugin SDK — Three Communication Channels"
        body: "Plugins connect to the engine through three channels simultaneously. Channel 1: WebSocket (same as agents — filesystem, git, terminal, LLM access). Channel 2: Multiplexed events (real-time subscriptions to tasks, chat, jobs, swarm, calendar, review-merge). Channel 3: HTTP REST (CRUD for threads, tasks, projects, environments). Plugins run inside the engine — no separate agent instance needed."
        reverse: true
        diagram: |
          ┌──────────────────────────────────┐
          │  Your Plugin                     │
          ├──────────────────────────────────┤
          │ Ch.1 WS     → fs, git, llm, ... │
          │ Ch.2 Mux    → events, tasks, ... │
          │ Ch.3 HTTP   → CRUD, projects, ...│
          ├──────────────────────────────────┤
          │ onStart() → receives PluginContext│
          │ onMessage() → incoming messages  │
          │ Lifecycle managed by engine      │
          │ Trigger-based auto-start         │
          └──────────────────────────────────┘

      - type: feature-block
        heading: "Client SDK — Build Any Interface"
        body: "72 lazily-initialized REST API modules covering every domain: chat, agents, git, tasks, browser, file, LLM, vector DB, knowledge, swarm, orchestrator, environments, memory, calendar, and more. 33 WebSocket modules for real-time events: shell PTY, chat, editor, LSP, browser, tasks, jobs, swarm, debug. Connection presets (MINIMAL, STANDARD, FULL) and unified event filtering with wildcards and predicates."
        diagram: |
          const client = new CodeBoltClient({
            defaultPreset: 'standard'
          });

          // 72 REST APIs
          const tasks = await client.tasks.getTasks();
          const agents = await client.agents.list();

          // 33 WebSocket streams
          client.onEvents('tasks.*', (data) => {
            updateDashboard(data);
          });

          // Build: dashboards, mobile apps,
          // Slack bots, VS Code extensions,
          // CLI tools, anything.

      - type: feature-block
        heading: "Plugin Discovery & Lifecycle"
        body: "Plugins are discovered from project .codeboltPlugins/ directories and global ~/.codebolt/plugins/. Each plugin declares itself in package.json with a codebolt.plugin key. The PluginProcessManager handles loading, starting, stopping, and trigger-based auto-start. Plugins receive a PluginContext with their ID, directory, and manifest. Built-in plugins include cloud integration, remote execution, and test execution."
        reverse: true
        diagram: |
          Discovery:
          ├─ .codeboltPlugins/ (per-project)
          └─ ~/.codebolt/plugins/ (global)

          Lifecycle:
          discover → load → start → running
                              ↕
                    stop ← trigger-based

          Built-in:
          ├─ cloud-plugin
          ├─ remote-execution-plugin
          └─ test-execution-plugin

      - type: cta-block
        heading: "Three SDKs. Every layer open."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Back to Engine", href: "/engine", variant: "secondary" }

  # ── Engine: Agent Extensibility ────────────
  - slug: "engine/agent-extensibility"
    title: "Agent Extensibility — Codebolt"
    sections:

      - type: page-header
        title: "Agent Extensibility"
        subtitle: "Multiple agent types. 675+ skills. From no-code remix to full code custom."

      - type: centered-text
        variant: "thesis"
        text: "Every agent in Codebolt is extensible. Remix agents let you customize without code. Flow agents give you visual composition. Custom agents give you full SDK access. All agents share the same 675+ skill library and capability system."

      - type: feature-block
        heading: "Remix Agents — No-Code Customization"
        body: "Remix agents inherit from a base agent and add custom instructions in YAML frontmatter + Markdown body. Stored as .md files in .codebolt/agents/remix/ — git-friendly, versionable, mergeable. Declare supported languages, frameworks, routing rules, and LLM model fallback chains. No code required."
        diagram: |
          .codebolt/agents/remix/my-agent.md:
          ---
          name: Python Testing Expert
          baseAgent: code-generation
          metadata:
            agent_routing:
              supportedlanguages: [python]
            defaultagentllm:
              modelorder: [gpt-4, claude, local]
          ---
          You are a Python testing expert.
          Write pytest tests with fixtures...

      - type: feature-block
        heading: "Flow Agents — Visual Composition"
        body: "Build agent workflows visually using the LiteGraph-based flow editor. Create .agentflow files with nodes, connections, and data flow. The runtime service executes the flow graph. Combine multiple agent capabilities into complex workflows without writing orchestration code."
        reverse: true
        diagram: |
          ┌─────────┐    ┌─────────┐    ┌─────────┐
          │ Analyze  │───→│ Generate │───→│ Review  │
          │ Code     │    │ Tests    │    │ Output  │
          └─────────┘    └─────────┘    └─────────┘
               │                              │
               └──────── feedback ────────────┘

          Visual editor. .agentflow files.
          Runtime executes the graph.

      - type: feature-block
        heading: "Custom Agents — Full SDK Access"
        body: "Write agents in JavaScript/TypeScript with complete control over the agentic loop. Connect via codeboltjs as child processes. Access all 63+ SDK modules. Implement custom decision logic, tool selection, memory management, and error handling. Your agent is your program."
        diagram: |
          import { codebolt } from 'codeboltjs';

          codebolt.onMessage(async (msg) => {
            // Step 1: Analyze
            const code = await codebolt.fs.readDir('/src');
            // Step 2: Decide (your logic)
            const plan = await codebolt.llm.chat({...});
            // Step 3: Execute
            await codebolt.terminal.run('npm test');
            // Step 4: Report
            await codebolt.chat.sendMessage(result);
          });

      - type: feature-block
        heading: "Remote Agents"
        body: "Agents running in external environments connect via HTTP/WebSocket endpoints. A remote agent has the same capabilities as a local one — full SDK access through the network. This enables distributed agent architectures where specialized agents live on specialized hardware."
        reverse: true
        diagram: |
          Local Codebolt Instance
                │
          ┌─────┼──────────────────┐
          │ Remote Agent (GPU VM)  │
          │ → connects via WS      │
          │ → full SDK access      │
          │ → specialized hardware │
          └────────────────────────┘

      - type: feature-block
        heading: "675+ Skills Organized by Domain"
        body: "72 tool domains with 675+ individual tools. File operations (read, write, search, diff, create). Git (commit, push, pull, branch, merge, revert). Browser (navigate, screenshot, click, type, scroll). Terminal (execute, stream, manage PTY). LLM (chat, embed, count tokens). Vector DB (store, query, semantic search). Agent control (start, stop, list, spawn sub-agents). Memory & knowledge (persist, retrieve, graph queries). Skills are scoped by environment capabilities."
        diagram: |
          Agent declares needed capabilities:
          → browser-automation
          → llm-embedding
          → vector-storage

          Environment checks:
          → Playwright available? ✓
          → ONNX.js available? ✓
          → Redis running? ✓

          Agent gains access to:
          675+ tools across 72 domains
          Scoped by what's available

      - type: feature-block
        heading: "Role-Specific LLM Configuration"
        body: "Each agent can declare different LLM configurations for different roles. Use GPT-4 for planning, Claude for code generation, a local model for repetitive tasks. Define fallback chains — if the primary model is unavailable, automatically try alternatives. Per-agent, per-task, per-role model selection. 17+ cloud providers plus Ollama and LM Studio."
        reverse: true
        diagram: |
          metadata:
            llm_role:
              - role: planning
                modelorder: [gpt-4, claude-opus]
              - role: coding
                modelorder: [claude-sonnet, gpt-4]
              - role: review
                modelorder: [local-llama, gemini]

          Fallback: if primary unavailable,
          try next in chain automatically.

      - type: cta-block
        heading: "Every agent is extensible."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Back to Engine", href: "/engine", variant: "secondary" }

  # -- Engine: Dynamic Scalable Evolving Memory
  - slug: "engine/dynamic-scalable-evolving-memory"
    title: "Dynamic Scalable Evolving Memory - Codebolt"
    sections:

      - type: product-hero-stack
        eyebrow: "DYNAMIC SCALABLE EVOLVING MEMORY"
        title: "A memory substrate agents can grow, reshape, and inject at runtime"
        subtitle: "Codebolt memory is not a fixed conversation summary. It is an active engine layer that can ingest chats, code, prompts, tasks, events, and relationships; create new memory structures; evolve context rules; and inject the right memory into each agent run under budget."
        buttons:
          - { label: "Explore Architecture", href: "/architecture", variant: "primary" }
          - { label: "Back to Engine", href: "/engine", variant: "secondary" }
        stackTitle: "Memory runtime"
        stackItems:
          - { label: "Scalable", value: "memory grows as the system is used" }
          - { label: "Dynamic", value: "memory structures are primitives, not fixed schemas" }
          - { label: "Evolving", value: "agents can change structures and context rules" }
          - { label: "Injectable", value: "CAE injects memory by rules and budgets" }
          - { label: "Active", value: "background memory processes keep working" }
          - { label: "Reactive", value: "hooks and events trigger memory updates" }
        footer: "The memory layer is part of the engine runtime, not a prompt appendix."

      - type: centered-text
        variant: "thesis"
        text: "Most agent memory products start with a fixed shape: summaries, preferences, key points, maybe mistakes. Codebolt ships memory primitives. You can decide what memory means for a project: unfinished tasks, negative patterns, positive patterns, object relationships, code facts, prompt behavior, agent habits, customer context, or a structure no one anticipated when the agent started."

      - type: bento-grid
        kicker: "SIX MEMORY PROPERTIES"
        heading: "Dynamic, scalable, evolving memory"
        description: "The important part is not only that agents remember. It is that the memory substrate can grow, restructure, react, and decide what should enter context."
        columns: 3
        items:
          - title: "Scalable memory"
            tag: "SCALABLE"
            span: 2
            description: "Memory grows as Codebolt is used. Agent chats, code changes, prompts, tool traces, tasks, decisions, failures, and relationships can be ingested into durable stores and converted into useful structures such as positive patterns, negative patterns, object relationships, unresolved work, and project facts."
            visual: |
              usage keeps producing signal
              ├─ chats
              ├─ code
              ├─ prompts
              ├─ tools
              ├─ tasks
              └─ events
                    ↓
              memory keeps compounding
          - title: "Dynamic structures"
            tag: "DYNAMIC"
            description: "The memory shape is not predefined by Codebolt. If you do not want conversation summaries, skip them. If you only want unfinished tasks, create that memory. If you need object graphs, failure patterns, or domain-specific state, define those instead."
          - title: "Evolving schemas and rules"
            tag: "EVOLVING"
            description: "Agents can change memory structures at runtime. They can create new memory definitions, adjust ingestion, improve retrieval pipelines, and add Context Assembly rules that control what future agents receive."
          - title: "Injectable context"
            tag: "INJECTABLE"
            description: "Memory does not blindly flood the prompt. The Context Assembly Engine injects memory by scope variables, rules, retrieval pipelines, contribution rules, and token budgets."
          - title: "Active and reactive memory"
            tag: "ACTIVE"
            span: 2
            description: "Memory work can run in the background and react to the system. Hooks, events, schedules, task outcomes, conversation lifecycle events, and custom plugins can trigger ingestion, updates, consolidation, and new derived memory."
            visual: |
              event happens
                    ↓
              hook / ingestion pipeline
                    ↓
              update memory
                    ↓
              CAE changes future context

              memory is not passive storage

      - type: feature-block
        kicker: "01 · MEMORY PRIMITIVES"
        heading: "Not one memory format. A system for creating memory formats."
        body: "Codebolt separates memory into primitives: storage types, ingestion pipelines, retrieval pipelines, context rules, contribution rules, and budgets. Together they let a project define the memory it actually needs instead of accepting a fixed vendor schema."
        diagram: |
          YOU CAN DEFINE:
          ├─ unfinished tasks memory
          ├─ negative pattern memory
          ├─ positive pattern memory
          ├─ object relationship memory
          ├─ codebase fact memory
          ├─ prompt behavior memory
          └─ domain-specific memory

          USING PRIMITIVES:
          ├─ episodic logs
          ├─ persistent memory definitions
          ├─ vector search
          ├─ knowledge graph
          ├─ key-value state
          ├─ ingestion pipelines
          ├─ retrieval pipelines
          └─ context assembly rules

      - type: accordion-showcase
        kicker: "RUNTIME EVOLUTION"
        heading: "How memory changes while the system runs"
        description: "The memory layer can collect signal, derive structures, modify schemas, and change injection behavior without waiting for a new product release."
        visual:
          label: "Dynamic memory loop"
          code: |
            observe work
                  |
                  v
            create / update structures
                  |
                  v
            add rules + pipelines
                  |
                  v
            inject under budget
                  |
                  v
            future agents inherit
        items:
          - question: "Scale from raw usage"
            answer: "The memory system can consume agent chat, code, prompts, tool results, task state, project files, application events, and plugin events. Over time that raw usage becomes structured project intelligence."
          - question: "Create new structures"
            answer: "A project can add new persistent memory definitions for the exact shape it needs: unfinished tasks, issue clusters, component relationships, repeated user corrections, agent mistakes, winning strategies, or business-specific entities."
          - question: "Change structures at runtime"
            answer: "Because memory structures are engine primitives, agents and plugins can update schemas, ingestion behavior, and retrieval pipelines while work is happening. The structure of memory can evolve with the problem."
          - question: "Control injection"
            answer: "Context Assembly rules determine which memories are injected for a given agent, task, phase, thread, project, user, or swarm. Memory is selected and budgeted before it enters the prompt."
          - question: "React in the background"
            answer: "Hooks, events, schedules, and lifecycle triggers can run memory work without a user prompt. Memory can consolidate, update relationships, record failures, and prepare future context while agents continue working."

      - type: tabs-showcase
        kicker: "WHAT CAN MEMORY BECOME"
        heading: "The memory shape is programmable"
        description: "Codebolt can support normal chat memory, but the stronger idea is that memory can become whatever durable intelligence the agent system needs."
        tabs:
          - label: "Patterns"
            title: "Positive and negative pattern memory"
            body: "Track what works and what fails. Agents can record repeated mistakes, constraints that were missed, review feedback, successful approaches, and patterns that should influence future work."
            points:
              - "Negative patterns: failed assumptions, repeated bugs, bad plans"
              - "Positive patterns: validated approaches, successful workflows"
              - "Useful for self-correction and agent evaluation"
            visual:
              label: "pattern memory"
              code: |
                mistake_pattern
                ├─ trigger
                ├─ evidence
                ├─ correction
                └─ inject_when
          - label: "Tasks"
            title: "Unfinished work memory"
            body: "Instead of summarizing every conversation, a project can keep memory focused on open loops: unfinished tasks, blocked decisions, abandoned branches, stale todos, skipped tests, and follow-up actions."
            points:
              - "Created from chats, plans, TODOs, jobs, commits, and events"
              - "Injected only when relevant to the current task or file"
              - "Useful for long-running autonomous work"
            visual:
              label: "unfinished tasks"
              code: |
                open_loop
                ├─ task
                ├─ blocker
                ├─ owner
                └─ next_action
          - label: "Objects"
            title: "Object relationship memory"
            body: "Memory can become a relationship graph for code, product, people, tasks, agents, files, APIs, prompts, business objects, or any domain-specific entity."
            points:
              - "Relationships can be discovered from code and runtime events"
              - "Graph expansion adds related context"
              - "Useful for multi-agent coordination and architecture work"
            visual:
              label: "object graph"
              code: |
                Component -> uses -> API
                Agent -> owns -> Task
                Prompt -> caused -> Failure
                File -> implements -> Feature
          - label: "Signals"
            title: "Active and reactive signal memory"
            body: "Memory can keep working after the chat turn ends. Background processors, hooks, schedules, task events, action events, and plugin events can update memory continuously."
            points:
              - "Runs from event triggers, not only user prompts"
              - "Can consolidate and update derived memories"
              - "Fits monitoring and long-term autonomous agents"
            visual:
              label: "reactive memory"
              code: |
                onTaskFailure -> store pattern
                onAction     -> update object
                onSchedule   -> consolidate
                onWebhook    -> ingest event
          - label: "Injection"
            title: "Rule-based context injection"
            body: "The memory structure is only half the system. Context Assembly decides which memory should enter a given agent run, where it should be placed, and how much budget it gets."
            points:
              - "Rules evaluate scope variables and custom variables"
              - "Budgets prevent memory from flooding the prompt"
              - "Traces explain why memory was included"
            visual:
              label: "context injection"
              code: |
                if task_type = refactor
                and phase = debugging
                include:
                  - past_failures
                  - related_files
                  - review_notes

      - type: feature-block
        kicker: "02 · SCALABLE + INJECTABLE"
        heading: "Memory can grow without flooding every agent"
        body: "Scalable memory creates a second problem: the more the system learns, the less any single agent can read. Codebolt solves that through Context Assembly. Memory can grow in the background, but each agent receives only the slice selected by rules, retrieval pipelines, contribution logic, and token budgets."
        reverse: true
        diagram: |
          memory keeps growing:
          ├─ conversations
          ├─ code facts
          ├─ object graph
          ├─ positive patterns
          ├─ negative patterns
          └─ unfinished tasks

          CAE decides:
          ├─ which memory applies
          ├─ which retrieval pipeline to run
          ├─ where context is placed
          └─ how much budget it receives

          agent gets focused context,
          not the whole database

      - type: cta-block
        heading: "Give agents memory they can scale, reshape, and inject."
        buttons:
          - { label: "Explore Architecture", href: "/architecture", variant: "primary" }
          - { label: "Back to Features", href: "/engine", variant: "secondary" }

  # ── Engine: Multi-Agent (Single Env) ───────
  - slug: "engine/multi-agent"
    title: "Multi-Agent Scaling — Codebolt"
    sections:

      - type: page-header
        title: "Multi-Agent Scaling"
        subtitle: "Within a single environment: sub-agents, parallel execution, coordination, deliberation, and autonomous review."

      - type: centered-text
        variant: "thesis"
        text: "Running multiple agents isn't the hard part. Coordinating them is. Codebolt provides sub-agent spawning, grouped parallel execution, stigmergy-based coordination, pheromone ownership, deliberation councils, automatic review-merge, and drift tracking — all within a single environment."

      - type: feature-block
        heading: "Sub-Agent Spawning"
        body: "Any agent can spawn background child threads that run as full agent instances in parallel. Not async tasks — real agents with complete SDK access. Register children individually or in groups. Wait for individual completion, grouped completion, or any external event. Message-driven parent-child communication via WebSocket."
        diagram: |
          Parent Agent
            ├─ spawn('reviewer', task1) → Child 1
            ├─ spawn('tester', task2)  → Child 2
            ├─ spawn('docs', task3)    → Child 3
            │
            │  addToGroup('batch-1', [1,2,3])
            │
            └─ await groupCompletion('batch-1')
                      ↓
               All 3 complete in parallel
               → Merge results → Continue

      - type: feature-block
        heading: "Stigmergy-Based Coordination"
        body: "Traditional multi-agent systems use direct message passing — fragile, creates coupling, doesn't scale. Codebolt uses stigmergy: agents communicate indirectly through structured shared state. Each agent reads from and writes to a shared environment. Coordination emerges without explicit messaging. This is how biological swarms scale to millions."
        reverse: true
        diagram: |
          Message Passing (others):
          A → B → C → D (fragile chain)

          Stigmergy (Codebolt):
          A → [shared state] ← B
          C → [shared state] ← D
          No direct coupling.
          Scales: 2 → 200+ agents.

      - type: feature-block
        heading: "Pheromone-Based Task Ownership"
        body: "Agents deposit pheromones on tasks and files to signal interest and ownership. Configurable pheromone types. Aggregation system for conflict resolution when multiple agents target the same work. Lock/unlock mechanisms for exclusive access. This prevents the coordination breakdown that happens when independent agents collide."
        diagram: |
          Agent A deposits pheromone:
          → file: auth.ts (ownership)
          → task: refactor-auth (working)

          Agent B checks pheromones:
          → auth.ts: claimed by A
          → picks different task instead

          No collision. No merge conflict.
          Automatic coordination.

      - type: feature-block
        heading: "Agent Deliberation Council"
        body: "Agents propose options, debate tradeoffs, vote, and reach consensus. Deliberation types: decision, review, brainstorm, approval, vote. All stored per-project in .codebolt/agentdeliberation/ and fully traceable. This is how agents make architectural decisions collectively — not by one agent guessing."
        reverse: true
        diagram: |
          Agent A: proposes microservices
          Agent B: proposes monolith
          Agent C: analyzes tradeoffs
                ↓
          Vote: 2 for monolith, 1 for micro
                ↓
          Consensus: monolith
          Decision: logged + traceable
          Rationale: preserved

      - type: feature-block
        heading: "Automatic Review & Merge"
        body: "Agents create review-merge requests for their changes. Other agents provide feedback — approve, request changes, or comment. Conflict detection runs before merge. Pheromone-based coordination prevents overlapping work. The shadow git system handles the actual merge operations. No GitHub PR bottleneck. Agents do long tasks in parallel, review each other, and merge autonomously."
        diagram: |
          Agent A: implements feature
                ↓
          Review request created
                ↓
          Agent B: reviews → approves
          Agent C: checks conflicts → clear
                ↓
          Auto-merged by shadow git
          No human needed. Fully traced.

      - type: feature-block
        heading: "Drift Tracking — Two Levels"
        body: "Local Rust engine instances assess drift within each agent context — structural drift (architecture diverging from plan), scope drift (features expanding beyond intent), constraint drift (violations of rules), coverage drift (gaps in implementation). The global JavaScript layer aggregates signals across all agents, detecting systemic drift that no single agent would catch."
        reverse: true
        diagram: |
          Level 1: Rust (per-agent)
          → structural drift
          → scope drift
          → constraint drift
          → coverage drift

          Level 2: JavaScript (global)
          → aggregate all agent signals
          → detect systemic patterns
          → flag before it compounds

      - type: cta-block
        heading: "Coordination, not collision."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Back to Engine", href: "/engine", variant: "secondary" }

  # ── Engine: Multi-Environment Scaling ──────
  - slug: "engine/multi-environment"
    title: "Multi-Environment Scaling — Codebolt"
    sections:

      - type: page-header
        title: "Multi-Environment Scaling"
        subtitle: "Chain environments together. Proxy execution across machines. Any topology."

      - type: centered-text
        variant: "thesis"
        text: "One Codebolt instance can treat another as a coordinated environment. Agents in Environment A trigger work in Environment B, which can forward to Environment C. Linear chains, fan-out trees, peer-to-peer meshes. The proxy execution system is plugin-based — not hardcoded — so any environment can participate."

      - type: feature-block
        heading: "Proxy Execution — How It Works"
        body: "The RemoteExecutionPlugin runs in Environment B and claims the ExecutionGateway. It starts a ProviderServer on WebSocket port 3100. Environment A's provider connects to this WebSocket. When Agent A sends an execution request, the gateway routes it to Environment B. Environment B executes and streams results back in real-time. Notifications (progress, logs) flow bidirectionally."
        diagram: |
          Env A (your laptop)
          ├─ Agent sends ExecutionRequest
          ├─ Provider connects to Env B:3100
          │
          ↓ WebSocket bridge
          │
          Env B (Docker GPU server)
          ├─ RemoteExecutionPlugin (active)
          ├─ Claims ExecutionGateway
          ├─ ProviderServer on port 3100
          ├─ Executes request
          └─ Streams results back to Env A

      - type: feature-block
        heading: "Environment Chaining — Any Topology"
        body: "Environments can chain arbitrarily. Env A calls Env B which calls Env C. Or Env A fans out to B, C, and D simultaneously. Or environments form peer-to-peer meshes. Each environment runs its own full Codebolt instance. The proxy is plugin-based — any environment can claim the execution gateway. Lazy routing means gateways are only active when the RemoteExecutionPlugin is running."
        reverse: true
        diagram: |
          Linear:   A → B → C → D
          Fan-out:  A → [B, C, D]
          Tree:     A → B → [D, E]
                    A → C → [F, G]
          Mesh:     A ↔ B ↔ C ↔ A
          Hub:      [B, C, D] → A → [E, F]

          Any topology. Plugin-based routing.
          Each node = full Codebolt instance.

      - type: feature-block
        heading: "State Transfer via Git Bundles"
        body: "The Narrative Engine snapshots workspace state per-environment using shadow git with per-thread refs. Git bundles package these snapshots for transfer between environments. Import/export as tar.gz or git bundles. Bidirectional — both environments can exchange state. The narrative hierarchy (Objective → Thread → Agent Run → Snapshot) is preserved across transfers."
        diagram: |
          Env A:
          [workspace state] → shadow git
                           → git bundle (export)
                           → transfer to Env B

          Env B:
          git bundle (import) → shadow git
                             → [workspace restored]

          Hierarchy preserved:
          Objective → Thread → Agent Run → Snapshot

      - type: feature-block
        heading: "Provider System — Local Is First-Class"
        body: "The provider registry treats local, Docker, cloud, and hybrid environments identically. No special-case code for local vs remote. Providers declare capabilities (GPU, Python, browser, etc.). The engine routes work to the right provider based on capability requirements. Environment lifecycle: CREATED → STARTING → RUNNING → STOPPING → STOPPED, with heartbeat monitoring every 30 seconds."
        reverse: true
        diagram: |
          Provider Registry:
          ├─ local    (category: local)
          ├─ docker   (category: local)
          ├─ e2b      (category: cloud)
          ├─ cloud-vm (category: cloud)
          └─ hybrid   (category: hybrid)

          All identical interface.
          Capabilities declared per-provider.
          Route by capability match.
          Heartbeat: 30s health checks.

      - type: feature-block
        heading: "Use Cases for Multi-Environment"
        body: "GPU offloading — local agent sends training jobs to cloud GPU. Sandboxed execution — run untrusted code in isolated Docker containers. Distributed teams — each developer's Codebolt connects to a shared orchestration server. Progressive scaling — start local, add Docker, add cloud as you grow. Hierarchical — parent instance manages child instances, spawning and closing environments as needed."
        diagram: |
          GPU offload:
          laptop → cloud A100 → results back

          Sandboxed execution:
          main env → Docker sandbox → safe

          Distributed team:
          Dev A ←→ Orchestrator ←→ Dev B

          Progressive scaling:
          local → +Docker → +cloud → +more

      - type: cta-block
        heading: "Chain environments. Scale without limits."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Back to Engine", href: "/engine", variant: "secondary" }

  # ── Engine: Codebolt Native Applications ──
  - slug: "engine/codebolt-native-applications"
    title: "Codebolt Native Applications — Build Apps on the Agent Engine"
    sections:

      - type: product-hero
        eyebrow: "CODEBOLT NATIVE APPLICATIONS"
        title: "Applications that use the agent engine as their backend"
        subtitle: "Cloud-native applications were designed around cloud primitives. Codebolt-native applications are designed around Codebolt primitives: agents, plugins, memory, tasks, environments, dynamic panels, and cloud-scale execution."
        buttons:
          - { label: "Read App Docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/01_overview", variant: "primary" }
          - { label: "Explore the SDK", href: "/products/sdk", variant: "secondary" }
        media:
          label: "Codebolt-native architecture"
          placeholder: "App UI + plugin backend + agent runtime"
          alt: "Codebolt native application architecture"

      - type: centered-text
        variant: "thesis"
        text: "A Codebolt-native application is not just a web app with an AI chat box. It is an application whose workflow, backend, and runtime behavior are built around the Codebolt engine. The app can call agents, manage tasks, open dynamic panels, run plugins, coordinate environments, use memory, and scale work through local or cloud agent runtimes."

      - type: bento-grid
        kicker: "APPLICATION MODEL"
        heading: "Four ways to build on the engine"
        description: "Choose the level of integration that matches your product. Start with APIs, move into plugin-backed applications, embed UI directly inside Codebolt, or host the engine yourself."
        columns: 4
        gap: "none"
        items:
          - title: "Client SDK or Cloud API"
            tag: "External app"
            description: "Connect a third-party product to Codebolt through the <a href='/products/sdk'>Client SDK</a> or Cloud API. Your app keeps its own UI while Codebolt supplies agents, threads, tasks, jobs, git, memory, environments, and real-time sockets."
            span: 2
            visual: |
              your product
                 │ REST + WebSocket
                 ▼
              Codebolt server / Cloud API
              ├─ agents + threads
              ├─ tasks + jobs
              ├─ memory + knowledge
              └─ environments + tools
          - title: "Plugin-backed application"
            tag: "Plugin SDK"
            description: "Use the <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/05_plugins/01_overview'>Plugin SDK</a> as the backend for app features. The plugin can expose Hono-style routes, validate requests, run engine APIs, push events, and keep application logic close to the runtime."
          - title: "Dynamic panels"
            tag: "In-app UI"
            description: "Open <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/04_custom-uis/05_dynamic-panels'>dynamic panels</a> inside Codebolt so the application UI lives directly in the editor. Agents and plugins can open, update, stream to, and close panels during a workflow."
          - title: "Self-hosted engine"
            tag: "Embedded runtime"
            description: "Run Codebolt on your own server or infrastructure like an agent framework, but with engine-level capabilities already included: agents, plugins, memory, orchestration, provider routing, environments, and UI extension points."
          - title: "Cloud-scale backend agents"
            tag: "Scale"
            description: "Let applications invoke Cloud agents as backend workers. Codebolt Cloud can route runs, start sandboxes, stream status, preserve run state, and scale agent invocations independently from the application frontend."
          - title: "Runtime-native features"
            tag: "Engine"
            description: "Applications inherit engine primitives instead of rebuilding them: agent management, multi-agent coordination, plugin execution, memory, evals, tasks, jobs, environment lifecycle, logs, and provider/model routing."

      - type: feature-block
        kicker: "01 · CLIENT SDK AND API"
        heading: "Build any interface on top of Codebolt"
        body: "A third-party product can connect directly to a local Codebolt server or Codebolt Cloud using the Client SDK and APIs. That product can keep its own frontend, auth, domain model, and business workflow while delegating agent execution, task management, jobs, git operations, memory, environment control, and real-time updates to Codebolt. This is the lightest way to make an existing product Codebolt-native."
        cta: { label: "Explore the SDK", href: "/products/sdk" }
        diagram: |
          React / SaaS / internal tool
              │
              ├─ REST APIs
              ├─ WebSocket events
              └─ Cloud API
                    │
                    ▼
          Codebolt runtime
              ├─ chat + threads
              ├─ tasks + jobs
              ├─ agents + execution
              ├─ git + files
              ├─ memory + knowledge
              └─ environments

      - type: feature-block
        kicker: "02 · PLUGIN BACKEND"
        heading: "Use a plugin as the application backend"
        body: "For deeper integration, a Codebolt plugin can become the backend for a web application surface. The feedback form plugin is the small version of this pattern: the UI calls a plugin route, the plugin handles the request, updates state, emits events, and can use the full engine context. Larger applications can use the same shape for approvals, dashboards, review tools, business workflows, or vertical agent products."
        reverse: true
        cta: { label: "Read plugin-backed UI docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/04_plugin-backed-uis" }
        diagram: |
          UI panel
              │ codeboltPlugin.fetch('/feedback')
              ▼
          plugin.dynamicPanel.router(panelId)
              ├─ validate request
              ├─ call engine APIs
              ├─ run agents / jobs
              ├─ emit live events
              └─ return JSON

          plugin is the backend
          Codebolt is the runtime

      - type: feature-block
        kicker: "03 · DYNAMIC PANELS"
        heading: "Turn Codebolt into the application shell"
        body: "A Codebolt-native application can run inside the Codebolt Editor itself. Dynamic panels let plugins and agents create application UI at runtime, stream data into it, receive user actions, and adapt the interface to the workflow. That means Codebolt can become a planning tool, review console, support dashboard, data labeling surface, operations cockpit, or any domain app that needs agents as first-class workers."
        cta: { label: "Explore dynamic panels", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04_custom-uis/05_dynamic-panels" }
        diagram: |
          Codebolt Editor
              │
              ├─ project workspace
              ├─ agent threads
              ├─ terminal / files / git
              └─ dynamic app panels
                     ▲
                     │ messages + events
                     ▼
          plugin backend + engine APIs

          the editor becomes your app shell

      - type: feature-block
        kicker: "04 · CLOUD AND SELF-HOST"
        heading: "Run the same application locally, in Cloud, or on your infrastructure"
        body: "The application does not have to care whether work runs on a laptop, a cloud sandbox, a local server, or your own infrastructure. Codebolt can be used like an agent framework, but the framework already includes runtime UI, plugin lifecycle, memory, task state, environment routing, multi-agent coordination, and operational visibility. For Codebolt Cloud, applications can call backend agents through the API and scale each invocation independently."
        reverse: true
        cta: { label: "Explore Cloud", href: "/products/cloud" }
        diagram: |
          Codebolt-native app
              │
              ├─ local Codebolt server
              ├─ Codebolt Cloud API
              ├─ self-hosted engine
              └─ remote environments

          same app contract
          different execution topology

      - type: comparison-columns
        problem:
          heading: "Normal AI apps"
          items:
            - "Treat AI as a chat sidebar or one-off API call"
            - "Rebuild agent state, memory, task tracking, logs, and execution management from scratch"
            - "Need a separate backend for orchestration, tool access, scheduling, and long-running jobs"
            - "Often stop at one agent in one environment"
            - "Have to invent their own UI extension and plugin model"
        solution:
          heading: "Codebolt-native apps"
          items:
            - "Use Codebolt as the backend runtime for agents, plugins, memory, jobs, tasks, and environments"
            - "Can run as standalone apps, plugin-backed apps, dynamic panels, Cloud API clients, or self-hosted engine deployments"
            - "Get multi-agent coordination and multi-environment scaling as runtime capabilities"
            - "Can turn the Codebolt Editor into a custom application shell"
            - "Build domain software on top of an engine that can evolve the agents, plugins, and UI around the workflow"

      - type: feature-block
        kicker: "05 · WHAT YOU GET BY DEFAULT"
        heading: "Application infrastructure that already understands agents"
        body: "The reason this matters is leverage. A Codebolt-native application starts with the engine features already in place: agent portfolios, custom agents, plugins, memory, tasks, jobs, files, git, terminals, environment providers, model routing, event streams, observability, evaluations, and dynamic UI. Instead of building a server around an agent, you build the application on an engine that already knows how agent work behaves."
        diagram: |
          engine capabilities
          ├─ agent management
          ├─ custom agents + plugins
          ├─ memory + knowledge
          ├─ tasks + jobs + goals
          ├─ files + git + terminals
          ├─ model/provider routing
          ├─ local/cloud environments
          ├─ observability + evals
          └─ dynamic panels

          your app composes these
          instead of rebuilding them

      - type: cta-block
        heading: "Build applications around the engine, not beside it."
        buttons:
          - { label: "Read App Docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/01_overview", variant: "primary" }
          - { label: "Explore Codebolt Editor", href: "/products/editor", variant: "secondary" }

  # ── Product: CLI ───────────────────────────
  - slug: "products/cli"
    title: "Codebolt CLI — Multi-Agent Terminal Workspace"
    sections:

      - type: product-hero
        eyebrow: "CODEBOLT CLI"
        title: "A multi-agent terminal workspace"
        subtitle: "Run agent chat, parallel threads, project files, git, logs, settings, and multi-environment work from one TUI backed by the Codebolt engine."
        buttons:
          - { label: "Download CLI", href: "/download", variant: "primary" }
          - { label: "Read CLI Docs", href: "https://docs.codebolt.ai/docs/05_reference/06_codebolt-cli/02_root-command", variant: "secondary" }
        installLabel: "Install"
        installCommand: "npm i -g codebolt"
        media:
          label: "Codebolt CLI Demo"
          src: "/images/cli-1.gif"
          alt: "Codebolt CLI multi-agent terminal interface"

      - type: bento-grid
        kicker: "AGENT CHAT"
        heading: "A serious terminal chat surface for agent work"
        description: "Start with the familiar workflow: open the terminal, talk to an agent, attach project context, approve tool use, inspect steps, and keep the conversation moving without leaving the keyboard."
        columns: 3
        gap: "none"
        items:
          - title: "Agent conversations"
            tag: "Chat"
            description: "Run focused coding conversations with built-in agents, custom agents, or pinned project agents. Keep prompt, response, tool calls, and progress in a compact terminal-native flow."
            span: 2
            image:
              src: "/images/cli-agent-conversations.svg"
              alt: "Codebolt CLI agent conversation flow with prompt, response, tools, file confirmations, and checkpoints"
          - title: "Context controls"
            tag: "Context"
            description: "Use project context, file suggestions, slash commands, todos, plans, and structured widgets so the agent gets more than a raw prompt."
            image:
              src: "/images/cli-context-controls.svg"
              alt: "Codebolt CLI context controls for files, agents, models, todos, and action plans"
          - title: "Tool visibility"
            tag: "Tools"
            description: "See filesystem, terminal, browser, git, memory, and MCP/tool activity as first-class chat events instead of invisible background automation."
            image:
              src: "/images/cli-tool-visibility.svg"
              alt: "Codebolt CLI tool visibility across files, shell, browser, git, memory, MCP, and events"
          - title: "Review checkpoints"
            tag: "Review"
            description: "Track file writes, shadow git checkpoints, review requests, and confirmation prompts inside the same chat where the agent is doing the work."
            image:
              src: "/images/cli-review-checkpoints.svg"
              alt: "Codebolt CLI review checkpoint flow for file writes, approvals, and rollback"
          - title: "Models and agents"
            tag: "Control"
            description: "Pick providers, models, and agents from terminal dialogs. Change the working agent without leaving the TUI."
            image:
              src: "/images/cli-models-agents.svg"
              alt: "Codebolt CLI controls for selecting providers, models, and agents"

      - type: feature-block
        kicker: "01 · TERMINAL ORCHESTRATION"
        heading: "tmux-style agent work, not one linear chat"
        body: "Codebolt CLI is designed for the way agent work actually happens: one thread explores, another edits, another tests, another reviews. The TUI can show parent and child conversations together, keep windows arranged on a terminal canvas, and let you supervise parallel work from one keyboard-first surface."
        reverse: true
        image: "/images/cli-1.gif"
        imageAlt: "Codebolt CLI tmux-style terminal workspace showing multiple agent work panes in parallel"

      - type: accordion-showcase
        kicker: "MULTI-AGENT · MULTI-ENVIRONMENT"
        heading: "Run more than one agent, across more than one place"
        subtitle: "The CLI is backed by the Codebolt server runtime, so it is not limited to one local terminal loop. Use it as the operator surface for parallel threads, child agents, remote servers, and multi-environment work."
        visualLabel: "CLI orchestration map"
        visualImage:
          src: "/images/cli-orchestration-map.svg"
          alt: "Codebolt CLI orchestration map connecting one TUI to server runtime, local, Docker, remote, cloud, and fleet environments"
        items:
          - question: "Parallel agent threads"
            tag: "Threads"
            answer: "Run multiple conversations and agent tasks side by side instead of waiting on one linear session. Keep each thread scoped to its own work while still supervising the whole run."
          - question: "Window tiling"
            tag: "Tiling"
            answer: "Use a multi-window terminal canvas for agent work. Drag and arrange conversation windows, tile child threads, and keep long-running work visible without opening another tool."
          - question: "Server-backed runs"
            tag: "Runtime"
            answer: "The TUI connects to the Codebolt server over WebSocket. Local, Docker, cloud, and remote environments can share the same runtime model instead of trapping work inside one terminal process."
          - question: "Parent and child agents"
            tag: "Orchestrate"
            answer: "Keep a base conversation visible while child agents branch into focused subtasks. This is the terminal version of supervising a small agent team."
          - question: "Same state as Editor"
            tag: "Continuity"
            answer: "Because CLI, Editor, Cloud, and SDK sit on the same runtime, you can start work in the editor, continue in the terminal, and keep agent state moving across surfaces."

      - type: tabs-showcase
        kicker: "WORKSPACE TOOLS"
        heading: "More than chat: files, git, logs, settings"
        subtitle: "Codebolt CLI is also a terminal workspace. The surrounding panels matter because serious agent work needs inspection, debugging, configuration, and review."
        tabs:
          - label: "Files"
            title: "Project workspace"
            tag: "Files"
            description: "Open file tree and preview panels from the terminal. Agents can read, write, search, and explain project files while you keep the project structure in view."
            points:
              - "File tree and file preview stay close to the agent conversation."
              - "Autocomplete and search help attach the right project context."
              - "File read/write activity remains inspectable from the terminal."
            image:
              src: "/images/cli-files.png"
              alt: "Codebolt CLI project workspace with file tree and editor-style terminal panels"
            visual: |
              project
              ├─ files
              │  ├─ src/
              │  ├─ tests/
              │  └─ package.json
              ├─ preview
              ├─ search
              └─ autocomplete
          - label: "Git"
            title: "Git panels"
            tag: "Git"
            description: "Inspect git status and commits in the TUI while agent edits flow through Codebolt's runtime. Review changes where the agent work is happening."
            points:
              - "Review changed files while the agent run is still active."
              - "Use git status and commit panels without leaving the TUI."
              - "Keep checkpoints and code review in the same operator surface."
            image:
              src: "/images/cli-git.png"
              alt: "Codebolt CLI git panel showing changed files and repository status"
            visual: |
              git
              ├─ status
              │  ├─ modified: auth.ts
              │  ├─ added: auth.test.ts
              │  └─ deleted: old-session.ts
              ├─ commits
              └─ changed files
          - label: "Panels"
            title: "Operational panels"
            tag: "Panels"
            description: "Keep chat, review, logs, notifications, and connection status available together instead of spreading agent work across separate terminal windows."
            points:
              - "Keep chat beside status and review panels."
              - "Monitor connection state while long-running agents continue."
              - "Use the terminal as an operator console, not just a prompt."
            image:
              src: "/images/cli-panels.png"
              alt: "Codebolt CLI operational panels showing chat, notifications, connection status, and review state"
            visual: |
              panels
              ├─ chat
              ├─ notifications
              ├─ connection status
              └─ review state
          - label: "Logs"
            title: "Logs and observability"
            tag: "Observe"
            description: "Open server logs, agent logs, structured logs, notifications, and connection status from the same terminal UI. When something stalls, you can inspect the run instead of guessing."
            points:
              - "Stream server and agent logs inside the TUI."
              - "Inspect structured runtime events for debugging."
              - "Understand why an agent is waiting, failing, or retrying."
            image:
              src: "/images/cli-logs.png"
              alt: "Codebolt CLI logs panel showing runtime, server, and agent events"
            visual: |
              logs
              ├─ server
              ├─ agent
              ├─ structured events
              └─ notifications
          - label: "Settings"
            title: "Settings in terminal"
            tag: "Control"
            description: "Configure login, providers, models, pinned agents, themes, keybindings, and application settings without leaving the TUI."
            points:
              - "Choose providers and models from terminal dialogs."
              - "Set pinned agents and defaults for the project."
              - "Change theme, keybindings, and app settings in place."
            image:
              src: "/images/cli-settings.png"
              alt: "Codebolt CLI settings panel for providers, models, agents, themes, and keybindings"
            visual: |
              settings
              ├─ login
              ├─ providers + models
              ├─ pinned agents
              ├─ themes
              └─ keybindings

      - type: comparison-columns
        problem:
          heading: "Single-agent CLIs"
          items:
            - "Great for one focused agent chat"
            - "Terminal is mostly a prompt-and-response surface"
            - "Parallel work usually means multiple shells with disconnected state"
            - "Editor, CLI, and backend state are usually separate"
            - "Scaling beyond one local session requires a different system"
        solution:
          heading: "Codebolt CLI"
          items:
            - "Run and supervise multiple agent threads from one TUI"
            - "Use chat, files, git, logs, settings, provider/model controls, and windows together"
            - "Connect to local or remote Codebolt server runtimes"
            - "Continue the same work across CLI, Editor, Cloud, and SDK surfaces"
            - "Scale from terminal agent work to multi-environment orchestration without changing engines"

      - type: cta-block
        heading: "Run agents from the terminal. Keep the engine underneath."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Product: Editor ────────────────────────
  - slug: "products/editor"
    title: "Codebolt Editor — Desktop Agent Environment"
    sections:

      - type: product-hero
        eyebrow: "CODEBOLT EDITOR"
        title: "The desktop command center for agent work"
        subtitle: "A complete AI code editor, orchestration console, and runtime surface for Codebolt-native applications. Open projects, edit code, run terminals, talk to agents, inspect their work, manage plans, and launch runtime panels from one workspace."
        buttons:
          - { label: "Download Editor", href: "/download", variant: "primary" }
          - { label: "Read Editor Docs", href: "https://docs.codebolt.ai/docs/02_using-codebolt/02_surfaces/02_desktop-app/01_workspace-and-projects", variant: "secondary" }
        media:
          label: "Codebolt Editor Demo"
          src: "/images/desktop.png"
          placeholder: "Editor product screenshot"
          alt: "Codebolt Editor desktop agent workspace"

      - type: centered-text
        variant: "thesis"
        text: "Codebolt Editor is the desktop command center for the engine. Open projects, edit code, run terminals, talk to agents, inspect their work, manage plans, coordinate environments, install plugins, and launch application interfaces that run directly on the Codebolt runtime."

      - type: bento-grid
        kicker: "EDITOR CAPABILITIES"
        heading: "A full editor built around agent work"
        description: "The editor is not only chat next to files. It is a complete workspace where code, context, agents, planning artifacts, runtime panels, and observability live together."
        columns: 3
        gap: "none"
        items:
          - title: "Project workspace"
            tag: "Workspace"
            description: "Open <a href='https://docs.codebolt.ai/docs/02_using-codebolt/02_surfaces/02_desktop-app/01_workspace-and-projects'>workspaces</a> with file tree, editor state, chat threads, project-local config, checkpoints, indexes, codemap, and memory. Tune the <a href='https://docs.codebolt.ai/docs/02_using-codebolt/02_surfaces/02_desktop-app/02_panels-and-layout'>panel layout</a> and <a href='https://docs.codebolt.ai/docs/02_using-codebolt/02_surfaces/02_desktop-app/03_settings-and-profiles'>settings profiles</a> per project."
            span: 2
            image:
              src: "/images/editor-project-workspace.svg"
              alt: "Codebolt Editor project workspace with file tree, code, chat, and memory panels"
          - title: "AI coding surface"
            tag: "Editor"
            description: "Code editing, terminals, file explorer, project context, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/03_chat/01_overview'>chat</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/03_chat/04_checkpoints-and-rollback'>checkpoints and rollback</a>, and <a href='https://docs.codebolt.ai/docs/02_using-codebolt/03_chat/06_model-selection'>model selection</a> in one desktop surface."
            image:
              src: "/images/editor-coding-surface.svg"
              alt: "AI coding surface with editor, terminal, model selector, and checkpoint controls"
          - title: "Agent workspace"
            tag: "Agents"
            description: "<a href='https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/03_running-agents'>Run agents</a> from the project, including <a href='https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/02_built-in-agents'>built-in agents</a>, remixes, custom agents, third-party agents, and remote agents. Use <a href='https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/06_agent-portfolios'>agent portfolios</a> and the <a href='https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/08_thread-panel'>thread panel</a> to manage work."
            image:
              src: "/images/editor-agent-workspace.svg"
              alt: "Agent workspace with built-in agents, remixes, custom agents, and remote agents"
          - title: "Debug and observability"
            tag: "Observe"
            description: "Inspect <a href='https://docs.codebolt.ai/docs/02_using-codebolt/05c_agent-observability/02_agent-debug'>agent logs</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/05c_agent-observability/03_ai-debug-and-console'>LLM calls, token budgets, and console output</a>, plus <a href='https://docs.codebolt.ai/docs/02_using-codebolt/09b_code-observability/03_narrative-graph'>narrative graphs</a> and run history without leaving the workspace."
            image:
              src: "/images/editor-observability.svg"
              alt: "Debug and observability panels showing agent logs, LLM calls, token budgets, and narrative graphs"
          - title: "Planning tools"
            tag: "Plan"
            description: "<a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/02_roadmap'>Roadmaps</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/03_specs'>specs</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/04_ui-flow'>UI flows</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/05_requirement-plan'>requirement plans</a>, <a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/06_action-plan'>action plans</a>, and <a href='https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/07_tasks'>tasks</a> live beside the code so humans and agents share the same source of truth."
            image:
              src: "/images/editor-planning-tools.svg"
              alt: "Planning tools for roadmaps, specs, UI flows, requirement plans, action plans, and tasks"
          - title: "Runtime UI panels"
            tag: "Apps"
            description: "Agents and plugins can open <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/04_custom-uis/05_dynamic-panels'>dynamic panels</a>, stream data into them, and receive user actions back. Build a <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/04_custom-uis/07_build-your-first-dynamic-panel'>first panel</a>, package <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/05_plugins/05_dynamic-panel-plugins'>plugin-backed panels</a>, or create <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/01_overview'>custom agentic apps</a>."
            image:
              src: "/images/editor-runtime-panels.svg"
              alt: "Runtime UI panels opened by agents and plugins inside the editor"

      - type: feature-block
        kicker: "01 · ORCHESTRATION HUB"
        heading: "The control room for multi-environment agent work"
        body: "Codebolt Editor sits on top of the same server runtime used by CLI, cloud, and headless deployments. The editor becomes the human-facing control plane for agent runs that may execute locally, in Docker, in cloud sandboxes, on remote servers, or across provider-backed environments. You can monitor the run, inspect artifacts, review changes, and keep coordination state in one place."
        cta: { label: "Read multi-environment docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/08a_multi-environment-orchestration/01_overview" }
        image: "/images/editor-orchestration-hub.svg"
        imageAlt: "Codebolt Editor orchestration hub connected to local, Docker, cloud, remote, and fleet environments"

      - type: feature-block
        kicker: "02 · EXTENSIBLE EDITOR"
        heading: "Agents and plugins can extend the interface at runtime"
        body: "The editor is an application host. Plugins can add panels, commands, provider integrations, and backend behavior. Agents can open dynamic panels for reviews, dashboards, forms, status views, approvals, or domain-specific workflows. The UI is not fixed to a single sidebar or chat panel; it can change with the task."
        cta: { label: "Explore dynamic panels", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04_custom-uis/05_dynamic-panels" }
        reverse: true
        image: "/images/editor-extensible-interface.svg"
        imageAlt: "Extensible editor interface with plugin backend, commands, providers, hooks, and dynamic panels"

      - type: feature-block
        kicker: "03 · CODEBOLT-NATIVE APPS"
        heading: "Run full application experiences on the engine"
        body: "The biggest shift is that Codebolt Editor is not only where you write applications. It is also where Codebolt-native applications can run. A plugin can act as the backend, a dynamic panel can act as the frontend, and the Codebolt engine provides agents, tools, memory, events, project state, and execution. This is closer to cloud-native applications than a normal extension model: the app is designed around the runtime, not just hosted beside it."
        cta: { label: "Read custom agentic apps", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/01_overview" }
        image: "/images/editor-native-apps.svg"
        imageAlt: "Codebolt-native application running with dynamic panel frontend, plugin backend, agents, tools, memory, and project state"

      - type: bento-grid
        kicker: "DEVELOPMENT LIFECYCLE"
        heading: "Manage the full software lifecycle in one workspace"
        description: "Codebolt Editor connects planning, implementation, agent management, evaluation, optimization, and delivery instead of scattering them across disconnected tools."
        columns: 3
        gap: "none"
        items:
          - title: "Plan the work"
            tag: "Roadmap"
            description: "Capture product phases, features, specs, UI flows, and requirement plans as project files that agents can read before acting."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/01_overview"
            image:
              src: "/images/editor-lifecycle-plan.svg"
              alt: "Roadmap planning artifacts available inside Codebolt Editor"
          - title: "Break it into execution"
            tag: "Action Plan"
            description: "Create structured action plans with tasks, dependencies, parallel groups, and progress that agents can update while they work."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/06_action-plan"
            image:
              src: "/images/editor-lifecycle-action-plan.svg"
              alt: "Action plan with tasks, dependencies, parallel groups, and progress"
          - title: "Track tasks on Kanban"
            tag: "Tasks"
            description: "Manage standalone tasks, subtasks, statuses, and kanban columns alongside the codebase and agent message history."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/06_planning/07_tasks"
            image:
              src: "/images/editor-lifecycle-kanban.svg"
              alt: "Kanban board for tasks, statuses, and agent message history"
          - title: "Develop with agents"
            tag: "Build"
            description: "Run coding agents against the project context, inspect file edits, review checkpoints, and keep human control over the work."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/03_running-agents"
            image:
              src: "/images/editor-lifecycle-build.svg"
              alt: "Coding agent run with project context, file edits, checkpoints, and review controls"
          - title: "Manage agent portfolios"
            tag: "Agents"
            description: "Use built-in agents, remixes, custom agents, remote agents, and specialized teams without leaving the editor surface."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/06_agent-portfolios"
            image:
              src: "/images/editor-lifecycle-portfolios.svg"
              alt: "Agent portfolio with built-in agents, remixes, custom agents, remote agents, and specialized teams"
          - title: "Evaluate and optimize"
            tag: "Quality"
            description: "Define eval tasks, score outputs, compare runs, and run optimization loops that improve agents over iterations."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/05e_eval-and-optimization/01_overview"
            image:
              src: "/images/editor-lifecycle-quality.svg"
              alt: "Evaluation and optimization loop comparing agent runs and scores"
          - title: "Observe every run"
            tag: "Trace"
            description: "Use debug panels, AI call inspection, console streams, and narrative graphs to see why an agent made each decision."
            href: "https://docs.codebolt.ai/docs/02_using-codebolt/05c_agent-observability/01_overview"
            span: 2
            image:
              src: "/images/editor-lifecycle-trace.svg"
              alt: "Trace view connecting roadmap, specs, action plans, tasks, logs, evals, and optimization"
          - title: "Ship through the same runtime"
            tag: "Runtime"
            description: "Move from editor work to CLI, cloud, remote environments, or Codebolt-native application surfaces without changing the underlying engine."
            href: "/engine"
            image:
              src: "/images/editor-lifecycle-runtime.svg"
              alt: "Editor work shipping through the same runtime to CLI, cloud, remote, and app surfaces"

      - type: cta-block
        heading: "A desktop editor, orchestration console, and application runtime in one."
        buttons:
          - { label: "Download", href: "/download", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Product: 24/7 Autonomous Agent ─────────
  - slug: "products/autonomous-agent"
    title: "Codebolt 24/7 Autonomous Agent — Always-On Agents for Any Platform"
    sections:

      - type: product-hero-stack
        eyebrow: "CODEBOLT 24/7 AUTONOMOUS AGENT"
        title: "Always-on agents connected to every platform"
        subtitle: "Run autonomous agents on your own Codebolt server or in the cloud portal. Connect Telegram, Linear, webhooks, custom chat channels, native apps, schedules, hooks, memory, and multi-agent scaling through the same engine runtime."
        buttons:
          - { label: "Start Building", href: "/pricing", variant: "primary" }
          - { label: "Explore Plugins", href: "/engine/system-extensibility", variant: "secondary" }
        stackTitle: "Always-on runtime"
        stackItems:
          - { label: "Surfaces", value: "Telegram, Linear, webhooks, custom apps" }
          - { label: "Routing", value: "single, per-user, per-conversation, per-message, multi-thread" }
          - { label: "Triggers", value: "schedule, hooks, webhook, user request" }
          - { label: "Runtime", value: "self-hosted server or Codebolt Cloud" }
          - { label: "Scale", value: "memory, custom agents, plugins, multi-agent, multi-environment" }
        footer: "A long-running agent system, not a hosted chat widget."

      - type: centered-text
        variant: "thesis"
        text: "An autonomous agent is not just a hosted chat bot. In Codebolt it is a server-backed agent system: external platforms send messages or events into the gateway, the gateway maps them to the right thread strategy, agents use persistent memory and plans, plugins can modify applications in real time, and the runtime can scale across agents and environments as the workload grows."

      - type: bento-grid
        kicker: "PLATFORM INTEGRATIONS"
        heading: "Connect your agent to any surface"
        description: "Codebolt plugins let the autonomous agent meet users and systems where they already work. Chat channels, issue trackers, internal tools, webhooks, and Codebolt-native apps can all become front doors to the same server runtime."
        columns: 3
        gap: "none"
        items:
          - title: "Chat channel plugins"
            tag: "Telegram / Slack / Custom"
            description: "Build chat plugins like Telegram channel integrations so users can talk to a Codebolt server instance from external messaging platforms."
            span: 2
            image:
              src: "/images/autonomous-platform-integrations.svg"
              alt: "Chat channel plugins routing Telegram, Slack, and custom chat messages into a Codebolt agent thread"
          - title: "Application plugins"
            tag: "Linear / Jira / GitHub"
            description: "Plugins like Linear agent integrations can convert platform events, issues, comments, and workflow changes into agent sessions."
            image:
              src: "/images/autonomous-application-plugins.svg"
              alt: "Application plugin turning a Linear issue event into an agent session and platform updates"
          - title: "Custom platform adapters"
            tag: "Plugins"
            description: "Write custom plugins for internal tools, customer portals, monitoring systems, or any platform with an API."
            image:
              src: "/images/autonomous-platform-adapters.svg"
              alt: "Custom adapters connecting internal tools, customer portals, and monitoring APIs to the Codebolt gateway"
          - title: "Codebolt-native apps"
            tag: "Runtime apps"
            description: "Use plugins and custom Codebolt-native applications to let agents modify product state, dashboards, panels, and workflows in real time."
            image:
              src: "/images/autonomous-native-apps.svg"
              alt: "Codebolt-native app panels updated by an autonomous agent"
          - title: "Remote webhooks"
            tag: "Webhooks"
            description: "Expose remote webhook entry points so third-party systems can trigger agent work without a human opening a prompt."
            image:
              src: "/images/autonomous-remote-webhooks.svg"
              alt: "Remote webhook payload routing into an autonomous agent run"

      - type: accordion-showcase
        kicker: "ROUTING + DEPLOYMENT"
        heading: "Self-host it, use Cloud, and route every conversation correctly"
        subtitle: "The server gateway decides how incoming platform messages become agent work. That lets one integration behave like a shared chat, a per-user assistant, a per-conversation support agent, or a multi-thread workflow."
        visualLabel: "Gateway routing model"
        visualImage:
          src: "/images/autonomous-gateway-routing.svg"
          alt: "Gateway routing model for autonomous agents across external platforms and thread strategies"
        items:
          - question: "Self-host locally or on your own server"
            answer: "Run Codebolt server wherever you need control: a local machine, private VM, internal network, or your own deployment. The same plugin and gateway model works without forcing you into hosted infrastructure."
          - question: "Use the cloud portal when you do not want to host"
            answer: "Use Codebolt Cloud as the managed control plane for teams that want always-on agents without maintaining the runtime themselves."
          - question: "Route by client and conversation shape"
            answer: "Gateway routing supports different thread strategies: shared chats, one thread per user, one thread per conversation, one thread per message, or multiple coordinated threads."
          - question: "Keep client communication flexible"
            answer: "Different clients need different routing. A support inbox, Telegram bot, Linear issue worker, webhook monitor, and Codebolt-native app do not have to use the same conversation model."

      - type: tabs-showcase
        kicker: "ALWAYS-ON WORK MODES"
        heading: "Autonomous agents can start from schedules, hooks, webhooks, or users"
        subtitle: "Long-term monitoring and background work becomes practical when schedules, calendar plans, hooks, platform events, and custom plugins all feed the same agent runtime."
        tabs:
          - label: "Schedule"
            title: "Work on a schedule"
            tag: "Calendar + plans"
            description: "Use calendar and plan structures to schedule recurring or future agent work, then route triggered tasks through the gateway."
            points:
              - "Run daily, weekly, or time-based tasks."
              - "Attach planned work to threads and task state."
              - "Use persistent memory so recurring jobs improve over time."
            image:
              src: "/images/autonomous-schedule.svg"
              alt: "Scheduled work flowing from calendar plans through the gateway to an agent thread"
          - label: "Hooks"
            title: "React to events as they happen"
            tag: "Runtime hooks"
            description: "Hooks let agents respond to events beyond time: application changes, plugin events, workflow transitions, monitoring alerts, or custom runtime signals."
            points:
              - "Monitor long-running systems without polling manually."
              - "React when a plugin, app, or workflow emits an event."
              - "Combine hooks with custom agents for domain-specific behavior."
            image:
              src: "/images/autonomous-hooks.svg"
              alt: "Runtime hooks turning plugin, app, workflow, and monitoring events into agent actions"
          - label: "Webhooks"
            title: "Accept remote webhook triggers"
            tag: "Remote events"
            description: "Remote systems can call webhooks to trigger autonomous work from outside the Codebolt UI."
            points:
              - "Connect CI, issue trackers, support tools, and internal systems."
              - "Use gateway routing to choose the right thread strategy."
              - "Return results through plugins or platform replies."
            image:
              src: "/images/autonomous-webhooks.svg"
              alt: "Remote webhook trigger routing payload metadata to an agent run and platform response"
          - label: "User"
            title: "Work on direct user request"
            tag: "Chat + apps"
            description: "Users can still ask directly through chat channels, the editor, CLI, cloud portal, or custom Codebolt-native applications."
            points:
              - "One engine can serve many client surfaces."
              - "The same agent can continue from user messages, schedules, or hooks."
              - "Plugins can reply back to the originating platform."
            image:
              src: "/images/autonomous-user-request.svg"
              alt: "User requests from chat, cloud, apps, CLI, and editor routed through gateway, memory, and agent action"

      - type: feature-block
        kicker: "01 · MEMORY"
        heading: "Persistent memory keeps the intelligence alive"
        body: "Autonomous work only matters if the agent can retain context across runs. Codebolt's memory structure lets agents keep durable knowledge across sessions, tasks, users, and time. That memory can be retrieved into future conversations, scheduled jobs, webhook-triggered work, and long-term monitoring loops."
        image: "/images/autonomous-memory.svg"
        imageAlt: "Persistent memory structure feeding a memory-aware autonomous agent"

      - type: feature-block
        kicker: "02 · SCALE"
        heading: "Scale from one always-on agent to coordinated agent systems"
        body: "A Codebolt autonomous agent can start as one worker and grow into multi-agent, multi-environment execution. The same engine supports custom agents, custom plugins, shared memory, multi-thread routing, and multi-environment scaling when the task needs more capacity or coordination."
        reverse: true
        image: "/images/autonomous-scale.svg"
        imageAlt: "Autonomous agent scale path from one worker to coordinated agents across local server cloud and fleet environments"

      - type: cta-block
        heading: "Build an autonomous agent that lives where your work happens."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore Plugins", href: "/engine/system-extensibility", variant: "secondary" }

  # ── Product: Cloud ─────────────────────────
  - slug: "products/cloud"
    title: "Codebolt Cloud — Agent Control Plane"
    sections:

      - type: product-hero
        eyebrow: "CODEBOLT CLOUD"
        title: "The cloud control plane for agent work"
        subtitle: "Run agents in managed or bring-your-own sandboxes, connect local Codebolt instances, schedule goals, monitor usage, and manage marketplace registries from one portal."
        buttons:
          - { label: "Open Cloud", href: "https://cloud.codebolt.ai", variant: "primary" }
          - { label: "Explore Sandboxes", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/08a_multi-environment-orchestration/01_overview", variant: "secondary" }
        media:
          label: "Codebolt Cloud Portal"
          src: "/images/cloud.png"
          placeholder: "Cloud product GIF / portal screenshot"
          alt: "Codebolt Cloud portal for agents, sandboxes, automations, usage, and registries"

      - type: centered-text
        variant: "thesis"
        text: "Codebolt Cloud lets you start in the browser, CLI, or desktop app and scale into managed or bring-your-own sandboxes. Run cloud agents, connect local Codebolt instances, schedule goals, monitor usage, and manage public or private plugin and template registries from one portal."

      - type: bento-grid
        kicker: "CLOUD CAPABILITIES"
        heading: "Run and manage agents across every environment"
        description: "Cloud is not just a hosted editor. It is the shared control plane for launching, routing, supervising, and scaling Codebolt work."
        columns: 3
        gap: "none"
        items:
          - title: "Bring your own sandboxes"
            tag: "Sandboxes"
            description: "Run cloud agents in managed or self-owned sandboxes such as <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/08a_multi-environment-orchestration/01_overview'>E2B, Daytona, Docker, worktrees, remote servers, or custom providers</a>. Start sandboxes from the portal UI, API calls, webhooks, or automations."
            span: 2
            image:
              src: "/images/cloud-sandboxes.svg"
              alt: "Cloud sandbox provider routing from portal API and automation into E2B Daytona Docker worktrees remote servers and custom providers"
          - title: "Scale from CLI or Desktop"
            tag: "Handoff"
            description: "Start local in the <a href='/products/cli'>CLI</a> or <a href='/products/editor'>Editor</a>, then scale the same work into Cloud when you need longer runs, remote capacity, team visibility, or scheduled execution."
            image:
              src: "/images/cloud-scale-handoff.svg"
              alt: "Local CLI and desktop work handed off to Codebolt Cloud for remote capacity and team visibility"
          - title: "Connect local instances"
            tag: "Local + Cloud"
            description: "Use the cloud plugin to connect local Codebolt instances to Cloud, manage local sessions from the portal, and hand work off between local and cloud runtimes without losing context."
            image:
              src: "/images/cloud-local-instances.svg"
              alt: "Cloud plugin connecting local and cloud Codebolt sessions to the portal"
          - title: "Automations and goals"
            tag: "Always-on"
            description: "Define goals, scheduled runs, webhook triggers, and API-triggered jobs so agents can operate on a cadence instead of waiting for a human to open a prompt."
            image:
              src: "/images/cloud-automations-goals.svg"
              alt: "Schedules webhooks and API jobs becoming Cloud agent goals"
          - title: "Backend agents for native apps"
            tag: "App backend"
            description: "Use Cloud agents as scalable backend workers for Codebolt-native applications. Apps can invoke agents directly through the API and let Cloud handle routing, sandboxing, execution, and run state."
            image:
              src: "/images/cloud-app-backend-card.svg"
              alt: "Codebolt-native app UI invoking Cloud API and scalable agent runs"

      - type: feature-block
        kicker: "01 · SANDBOX AGENTS"
        heading: "Start cloud agents in the sandbox you choose"
        body: "Codebolt Cloud can launch agent work into provider-backed environments instead of forcing everything into one hosted runtime. Use Codebolt-managed sandboxes, connect your own E2B or Daytona accounts, route work to Docker or worktree environments, or build a custom provider for your infrastructure. The portal, API, and automations all talk to the same environment model."
        cta: { label: "Read environment orchestration docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/08a_multi-environment-orchestration/01_overview" }
        image: "/images/Start_cloud_agents_in_the_sandbox.gif"
        imageAlt: "Codebolt Cloud launching agents into provider-backed sandbox environments"

      - type: feature-block
        kicker: "02 · LOCAL HANDOFF"
        heading: "Manage local Codebolt sessions from Cloud"
        body: "Cloud can connect to local Codebolt instances through the cloud plugin. That gives you a shared portal for local sessions, cloud sessions, and handoffs between them. You can begin in the desktop app or CLI, promote a run to cloud infrastructure, or keep a local machine as an environment Cloud can coordinate."
        reverse: true
        image: "/images/control_local_from_cloud.gif"
        imageAlt: "Codebolt Cloud portal managing desktop and CLI sessions through the cloud plugin"

      - type: feature-block
        kicker: "03 · AUTOMATIONS"
        heading: "Turn prompts into scheduled goals"
        body: "Cloud agents do not have to start from a person typing in a chat box. Define recurring goals, cron-style schedules, webhook triggers, or API-triggered jobs. Agents can triage issues, run maintenance, generate reports, watch repos, check deployments, or execute business workflows on a schedule."
        image: "/images/Turn_prompts_into_scheduled_goals.gif"
        imageAlt: "Codebolt Cloud turning prompts into recurring goals schedules webhooks and API jobs"

      - type: feature-block
        kicker: "04 · APP BACKENDS"
        heading: "Use Cloud agents as the backend for Codebolt-native applications"
        body: "Codebolt-native applications do not need to run every agent inside the user's local editor session. They can call the Cloud API, start the right agent in the right sandbox, stream status back to the application UI, and scale invocations independently from the frontend. The application owns the workflow; Codebolt Cloud supplies the agent runtime, provider routing, environment lifecycle, memory, logs, and execution state."
        reverse: true
        cta: { label: "Read custom agentic apps", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/04b_custom-agentic-applications/01_overview" }
        image: "/images/cloud-app-backends.svg"
        imageAlt: "Codebolt-native application calling Cloud APIs to route providers start sandboxes run workflows stream events and persist state"

      - type: feature-block
        kicker: "05 · OPERATIONS"
        heading: "Track usage, cost, and runtime activity"
        body: "When agents run across local machines, cloud sandboxes, API jobs, and scheduled automations, visibility matters. Codebolt Cloud gives teams a central place to track run history, usage, costs, token consumption, environment activity, and operational status across the whole agent fleet."
        image: "/images/cloud-operations.svg"
        imageAlt: "Codebolt Cloud operations dashboard tracking runs costs runtime activity failures retries teams and projects"

      - type: feature-block
        kicker: "06 · REGISTRY"
        heading: "Manage public and private marketplaces"
        body: "Cloud also acts as the registry layer for your agent ecosystem. Publish and install agents, plugins, MCP servers, templates, and reusable packages. Keep some public, keep internal ones private, mirror approved marketplace entries, and give teams a controlled catalog instead of unmanaged scripts."
        cta: { label: "Read marketplace docs", href: "https://docs.codebolt.ai/docs/02_using-codebolt/04_agents/04_the-marketplace" }
        image: "/images/cloud-registry.svg"
        imageAlt: "Codebolt Cloud registry managing public marketplace private registries agents plugins MCP servers templates and approved packages"

      - type: cta-block
        heading: "Start local. Scale through Cloud when the work grows."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Product: SDK ───────────────────────────
  - slug: "products/sdk"
    title: "Codebolt SDK — Build, Extend, and Scale on the Engine"
    sections:

      - type: page-header
        eyebrow: "CODEBOLT SDK"
        title: "The SDK layer for scalable agent software"
        subtitle: "Build custom agents, custom clients, plugins, providers, and Codebolt-native applications on top of the same engine that powers the Editor, CLI, Cloud, and autonomous agents."
        buttons:
          - { label: "Read SDK Docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/01_overview", variant: "primary" }
          - { label: "Codebolt Native Apps", href: "/engine/codebolt-native-applications", variant: "secondary" }
        pills:
          - "Agent SDK"
          - "Client SDK"
          - "Plugin SDK"
          - "Provider SDK"

      - type: centered-text
        variant: "thesis"
        text: "The SDK is the scalability layer of Codebolt. Use the Agent SDK and agent framework to control agent behavior, the Client SDK to build custom interfaces and integrate other applications, the Plugin SDK to extend the engine, and the Provider SDK to connect agent execution across platforms and environments."

      - type: bento-grid
        kicker: "SDK LAYERS"
        heading: "Build at every layer of the engine"
        description: "Codebolt is not just an app with an API. It exposes the layers you need to create agents, build interfaces, extend runtime behavior, connect external systems, and scale execution."
        columns: 4
        gap: "none"
        items:
          - title: "Agent SDK"
            tag: "codeboltjs"
            description: "Use <a href='https://docs.codebolt.ai/docs/05_reference/02_codeboltjs/01_intro'>codeboltjs</a> to create custom agents with direct access to files, git, terminal, browser, LLMs, memory, tasks, dynamic panels, environments, evals, and engine APIs."
            span: 2
            image:
              src: "/images/sdk-agent-layer.svg"
              alt: "Agent SDK diagram showing a custom agent calling codeboltjs modules for files git terminal LLM browser memory tasks jobs panels and environments"
          - title: "Agent framework"
            tag: "@codebolt/agent"
            description: "Build agents like you would with LangChain, Mastra, or other frameworks, but Codebolt-aware. Compose tools, workflows, processors, message modifiers, compaction, and execution control for agents tailored to your workflow."
            image:
              src: "/images/sdk-agent-framework.svg"
              alt: "Agent framework diagram composing tools workflows processors modifiers compaction and control"
          - title: "Client SDK"
            tag: "Custom clients"
            description: "Use the <a href='/engine/codebolt-native-applications'>Client SDK</a> to build custom web apps, internal tools, dashboards, vertical IDEs, mobile surfaces, or product integrations that talk to Codebolt over REST and WebSocket APIs."
            image:
              src: "/images/sdk-client-layer.svg"
              alt: "Client SDK diagram connecting custom interfaces to Codebolt engine state through REST and WebSocket APIs"
          - title: "Plugin SDK"
            tag: "Runtime extension"
            description: "Use the <a href='https://docs.codebolt.ai/docs/04_build-on-codebolt/05_plugins/01_overview'>Plugin SDK</a> to add backend capabilities, commands, routes, hooks, dynamic panels, provider integrations, marketplace packages, and app-specific runtime logic."
            image:
              src: "/images/sdk-plugin-layer.svg"
              alt: "Plugin SDK diagram showing plugin runtime extension routes hooks panels commands adapters and packages"
          - title: "Provider SDK"
            tag: "Agent routing"
            description: "Create custom agent providers and execution bridges so Codebolt can chain agent connections across platforms, environments, remote servers, and specialized runtimes."
            image:
              src: "/images/sdk-provider-layer.svg"
              alt: "Provider SDK diagram routing execution to local engines remote servers cloud sandboxes and custom platforms"
          - title: "Native applications"
            tag: "Composable"
            description: "Combine SDK layers to create <a href='/engine/codebolt-native-applications'>Codebolt-native applications</a>: a custom app UI, plugin backend, custom agents, provider routing, and cloud or self-hosted execution on the same engine."
            image:
              src: "/images/sdk-native-app-layer.svg"
              alt: "Native application diagram combining Client SDK Plugin SDK Agent SDK Provider SDK and engine services"

      - type: feature-block
        kicker: "01 · AGENT SDK"
        heading: "Create custom agents tailored to your workflow"
        body: "Codebolt lets teams build agents the way they build software: with code, modules, tools, workflows, and explicit control over the agent loop. The codeboltjs Agent SDK gives agents direct access to Codebolt engine capabilities, while the @codebolt/agent framework provides a higher-level interface for tools, workflows, reusable processor pieces, message modifiers, loop detection, and conversation compaction. Use it when a generic prompt is not enough and the agent needs to follow your product, team, or domain workflow."
        cta: { label: "Read codeboltjs docs", href: "https://docs.codebolt.ai/docs/05_reference/02_codeboltjs/01_intro" }
        image: "/images/sdk-agent-flow.svg"
        imageAlt: "Agent SDK and framework flow diagram for custom agent behavior"

      - type: feature-block
        kicker: "02 · CLIENT SDK"
        heading: "Build your own interfaces and integrations"
        body: "The Editor and CLI are clients of the engine. With the Client SDK, your application can be one too. Build a custom UI, vertical workspace, internal operations console, product-specific dashboard, or integration from another application. The client layer can call Codebolt APIs, subscribe to real-time sockets, manage threads, tasks, jobs, agents, environments, memory, git, files, and application state."
        reverse: true
        cta: { label: "Explore native apps", href: "/engine/codebolt-native-applications" }
        image: "/images/sdk-client-interface.svg"
        imageAlt: "Client SDK interface diagram showing a custom app connected through REST and WebSocket APIs to engine capabilities"

      - type: feature-block
        kicker: "03 · PLUGIN SDK"
        heading: "Extend the runtime, not just the UI"
        body: "Plugins let you add capabilities inside the Codebolt engine itself. A plugin can expose routes, connect to external APIs, register hooks, open dynamic panels, mediate application requests, push live events, add provider behavior, and serve as the backend for a Codebolt-native application. That means your product logic can live close to agents, memory, tasks, environments, and execution rather than in a disconnected service."
        cta: { label: "Read plugin docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/05_plugins/01_overview" }
        image: "/images/sdk-plugin-runtime.svg"
        imageAlt: "Plugin SDK runtime diagram showing lifecycle routes WebSocket multiplexed events hooks commands panels adapters and engine API access"

      - type: feature-block
        kicker: "04 · PROVIDER SDK"
        heading: "Route agent execution across platforms"
        body: "The provider layer lets Codebolt connect to execution sources beyond one local runtime. Build custom providers to bridge agent connections across platforms, environments, remote machines, cloud sandboxes, or specialized agent systems. This is how the SDK story becomes a scaling story: agent work can move through the right provider instead of being trapped inside one client or one machine."
        reverse: true
        cta: { label: "Read provider commands", href: "https://docs.codebolt.ai/docs/02_using-codebolt/02_surfaces/03_cli/04_provider-commands" }
        image: "/images/sdk-provider-routing.svg"
        imageAlt: "Provider SDK routing diagram sending Codebolt execution requests to local remote cloud custom and specialized backends"

      - type: feature-block
        kicker: "05 · CODEBOLT-NATIVE APPS"
        heading: "Combine SDKs into full applications"
        body: "The real power appears when the SDK layers are used together. Use the Agent SDK to control the agent flow, the Plugin SDK to provide backend application logic, the Client SDK to create the interface, and the Provider SDK to route execution across environments. The result is a Codebolt-native application: software that uses the Codebolt engine as its backend instead of rebuilding agents, plugins, memory, tasks, orchestration, and scaling from scratch."
        cta: { label: "Open native applications page", href: "/engine/codebolt-native-applications" }
        image: "/images/sdk-native-application.svg"
        imageAlt: "Codebolt-native application architecture combining Client SDK Plugin SDK Agent SDK Provider SDK and engine services"

      - type: bento-grid
        kicker: "WHAT YOU CAN BUILD"
        heading: "The SDK is for scaling beyond the default surfaces"
        description: "Use SDKs when you need something more specific than a stock editor, one terminal session, or one hosted agent."
        columns: 3
        gap: "none"
        items:
          - title: "Workflow-specific agents"
            tag: "Agents"
            description: "Create agents for code review, migration, compliance, support, research, release management, data labeling, product planning, or any domain workflow."
            image:
              src: "/images/sdk-workflow-agents.svg"
              alt: "Workflow-specific agents diagram for review migration support and release workflows"
          - title: "Custom product interfaces"
            tag: "Clients"
            description: "Build your own UI on top of Codebolt: dashboards, vertical IDEs, internal portals, mobile apps, customer-facing tools, or embedded product surfaces."
            image:
              src: "/images/sdk-custom-interfaces.svg"
              alt: "Custom product interface diagram for web mobile and embedded surfaces"
          - title: "Engine extensions"
            tag: "Plugins"
            description: "Add integrations, routes, panels, hooks, commands, marketplace packages, backend logic, and domain capabilities directly into the engine runtime."
            image:
              src: "/images/sdk-engine-extensions.svg"
              alt: "Engine extensions diagram showing plugin routes hooks panels commands and packages"
          - title: "Execution bridges"
            tag: "Providers"
            description: "Route agent work to local runtimes, cloud sandboxes, remote servers, or third-party agent platforms using custom providers."
            image:
              src: "/images/sdk-execution-bridges.svg"
              alt: "Execution bridges diagram routing providers to local runtimes cloud sandboxes remote servers and agent platforms"
          - title: "Packaged engine apps"
            tag: "Native apps"
            description: "Package Codebolt into your own application or make Codebolt itself become the shell for your app through panels, plugins, and custom clients."
            image:
              src: "/images/sdk-packaged-apps.svg"
              alt: "Packaged engine app diagram showing app shell client plugin and engine"
          - title: "Scalable agent systems"
            tag: "Scale"
            description: "Grow from one custom agent to multi-agent, multi-environment workflows without changing the foundation."
            image:
              src: "/images/sdk-scalable-systems.svg"
              alt: "Scalable agent systems diagram growing from one agent to multi-agent multi-environment execution"

      - type: comparison-columns
        problem:
          heading: "Single-surface agent tools"
          items:
            - "Let you use their agent, but not build your own agent runtime around your workflow"
            - "Expose a fixed UI instead of a client SDK for custom applications"
            - "Treat plugins as add-ons instead of runtime backends"
            - "Do not provide a provider layer for chaining execution across platforms"
            - "Force teams to rebuild memory, tasks, jobs, orchestration, and scaling around the tool"
        solution:
          heading: "Codebolt SDK"
          items:
            - "Agent SDK and framework let you control agent flow, tools, processors, workflows, and compaction"
            - "Client SDK lets you build custom interfaces and integrate Codebolt into other applications"
            - "Plugin SDK lets you extend the engine and run app backend logic inside the runtime"
            - "Provider SDK lets you bridge agent execution across environments and platforms"
            - "Together, the SDK layers let teams build Codebolt-native applications that scale with the engine"

      - type: cta-block
        heading: "Build on the engine. Scale beyond the default app."
        buttons:
          - { label: "Read SDK Docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/01_overview", variant: "primary" }
          - { label: "Explore Native Apps", href: "/engine/codebolt-native-applications", variant: "secondary" }

  # ── Use Case: Orchestration ────────────────
  - slug: "engine/agent-orchestration"
    title: "Codebolt Orchestration — Multi-Agent at Scale"
    sections:

      - type: page-header
        title: "Codebolt as Orchestration Engine"
        subtitle: "50-100+ agents across multiple environments. Coordination, governance, and scaling — built into the engine."

      - type: centered-text
        variant: "thesis"
        text: "When you need more than one agent, you need orchestration. Not a layer on top of 5 different tools — an engine that runs agents AND coordinates them. Stigmergy-based coordination, agent deliberation councils, automatic review and merge, drift tracking, and guardrails."

      - type: feature-block
        heading: "Stigmergy-based coordination"
        body: "Traditional multi-agent systems use direct message passing — fragile and doesn't scale. Codebolt uses stigmergy: agents communicate through structured shared state. Pheromone-based task ownership prevents conflicts. The engine manages sequencing, dependencies, and resource allocation."
        diagram: |
          Agent A → shared state ← Agent B
                         ↕
          Agent C → shared state ← Agent D
          Pheromones: ownership signals
          No direct messaging needed
          Scales: 2 agents → 200 agents

      - type: feature-block
        heading: "Multi-environment scaling"
        body: "The provider system lets one Codebolt instance treat another as a coordinated environment. Run agents across local, Docker, cloud, and hierarchical setups. Each environment has full lifecycle management with heartbeat monitoring. Git bundles transfer state between environments."
        reverse: true
        diagram: |
          Main Instance
                │
          ┌─────┼──────┐
          ↓     ↓      ↓
          local docker  cloud
          │      │      │
          └──────┼──────┘
           git bundle state transfer
           heartbeat monitoring

      - type: feature-block
        heading: "What Paperclip can't do"
        body: "Paperclip orchestrates agents but doesn't run them. You need to bring Claude Code, OpenClaw, Cursor, and wire them together. Codebolt IS the engine — it runs agents AND orchestrates them. One system instead of five tools stitched together. And every agent has access to the full 63-module SDK, not just whatever each external tool exposes."
        diagram: |
          Paperclip:
          ✓ Org charts, budgets, governance
          ✗ Doesn't run agents
          ✗ Requires external tools
          ✗ Limited by each tool's API

          Codebolt Orchestration:
          ✓ Runs agents (63-module SDK)
          ✓ Coordinates (stigmergy)
          ✓ Governance (guardrails)
          ✓ One engine, not five tools

      - type: feature-block
        heading: "Agent deliberation and automatic review"
        body: "Agents propose options, debate tradeoffs, vote, and reach consensus. Review-merge requests let agents review each other's work without GitHub PR bottleneck. Conflict detection runs before merge. Drift tracking catches deviation across all agents. Every decision is logged and traceable."
        reverse: true
        diagram: |
          Agent A: implements feature
          Agent B: reviews code
          Agent C: checks for conflicts
          Agent D: runs tests
                ↓
          Auto-merged. Decision logged.
          No human bottleneck needed.

      - type: cta-block
        heading: "Orchestration built into the engine."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Use Case: Custom Agent Development ─────
  - slug: "use-cases/custom-agent-development"
    title: "Custom Agent Development — Codebolt"
    sections:

      - type: page-header
        title: "Build agents that are actually your software."
        subtitle: "Use Codebolt to write custom agents with your own loop, tools, models, memory, guardrails, and product logic."

      - type: centered-text
        variant: "thesis"
        text: "Most agent products let you customize prompts. Codebolt lets you customize the agent itself. Write the loop in code, call the SDK directly, shape memory, route models per task, and package repeatable behavior as agents your team can run anywhere."

      - type: card-grid
        heading: "What you can customize"
        cards:
          - title: "The agent loop"
            body: "Control planning, tool choice, memory reads, retries, reviews, commits, and handoffs. The agent is a program you own, not a hidden prompt behind a chat box."
            visual: |
              observe → plan → act
              review → retry → commit
              your logic at every step
          - title: "Tools and SDK access"
            body: "Use filesystem, git, terminal, browser, LLM, memory, task, notification, and orchestration modules from the Codebolt SDK. Agents can work inside the same engine as the CLI, Editor, Cloud, and server."
            visual: |
              agent.ts
                → codebolt.fs
                → codebolt.git
                → codebolt.memory
                → codebolt.llm
          - title: "Model and provider routing"
            body: "Use different providers for different parts of the work. Route planning, coding, review, extraction, and repetitive operations to the model that fits the job."
            visual: |
              planner → GPT
              coder → Claude
              reviewer → Gemini
              local tasks → Ollama

      - type: feature-block
        heading: "From one custom agent to a team of agents"
        body: "Start with a single specialist agent. Add reviewers, test agents, documentation agents, deployment agents, and monitors as the workflow grows. Because the agents run on the same engine, they can share memory, tasks, state, plugins, and environments."
        diagram: |
          custom-agent
             ↓
          reviewer-agent
          test-agent
          docs-agent
          deploy-agent
             ↓
          coordinated by Codebolt

      - type: cta-block
        heading: "Build agents as real software."
        buttons:
          - { label: "Explore Agent Extensibility", href: "/engine/agent-extensibility", variant: "primary" }
          - { label: "Read SDK Docs", href: "https://docs.codebolt.ai/docs/04_build-on-codebolt/01_overview", variant: "secondary" }

  # ── Use Case: Coding Agent ─────────────────
  - slug: "use-cases/coding-agent"
    title: "Coding Agent — Codebolt"
    sections:

      - type: page-header
        title: "A coding agent that can grow past the chat window."
        subtitle: "Use Codebolt as a serious software agent for coding, review, tests, refactors, repositories, terminals, and multi-agent development work."

      - type: centered-text
        variant: "thesis"
        text: "Codebolt can start like a familiar coding agent: ask for a change, inspect the repo, edit files, run commands, and review output. The difference is that the same work can continue across CLI, Editor, Cloud, and custom agents without changing engines."

      - type: card-grid
        heading: "Coding workflows"
        cards:
          - title: "Repository-aware implementation"
            body: "Agents can inspect files, follow project conventions, edit code, run tests, and iterate until the change is coherent. Use the CLI for terminal-first work or the Editor for a visual coding surface."
            visual: |
              inspect repo
              patch files
              run tests
              explain result
          - title: "Parallel coding threads"
            body: "Run multiple coding tasks at once instead of one linear chat. Split exploration, implementation, review, docs, and verification across agent threads."
            visual: |
              thread 1 → frontend
              thread 2 → backend
              thread 3 → tests
              thread 4 → docs
          - title: "Review and merge loops"
            body: "Agents can review each other's work, identify conflicts, run checks, and prepare changes for merge. Codebolt is built for agent teams, not only individual chat sessions."
            visual: |
              agent A implements
              agent B reviews
              agent C tests
              merge when ready

      - type: feature-block
        heading: "Same coding state across surfaces"
        body: "Start in the Editor, continue in the CLI, push a long-running job to Cloud, or turn a repeated coding workflow into a custom agent. The engine remains the same, so the context, memory, tools, and plugins can carry forward."
        reverse: true
        diagram: |
          Editor ↔ CLI ↔ Cloud
             ↘      ↓      ↙
              Codebolt engine
                 memory
                 agents
                 plugins
                 environments

      - type: cta-block
        heading: "Use Codebolt as your coding agent."
        buttons:
          - { label: "Download Codebolt", href: "/download", variant: "primary" }
          - { label: "Explore CLI", href: "/products/cli", variant: "secondary" }

  # ── Use Case: Agent Cloud ──────────────────
  - slug: "use-cases/agent-cloud"
    title: "Agent Cloud — Codebolt"
    sections:

      - type: page-header
        title: "Run agents in the cloud without giving up the engine."
        subtitle: "Use Codebolt Cloud for hosted agents, sandboxes, webhooks, long-running tasks, and managed access to the same runtime used locally."

      - type: centered-text
        variant: "thesis"
        text: "Agent cloud should not mean a separate product with separate memory and separate tools. Codebolt Cloud is another surface on the same engine: run jobs remotely, connect webhooks, manage sandboxes, and keep work compatible with local and self-hosted Codebolt."

      - type: card-grid
        heading: "Cloud agent patterns"
        cards:
          - title: "Hosted long-running work"
            body: "Move slow or scheduled work out of your laptop. Run autonomous agents for monitoring, maintenance, research, code review, customer workflows, and background automation."
            visual: |
              schedule
              webhook
              user request
                 ↓
              cloud agent run
          - title: "Managed sandboxes"
            body: "Run agents in isolated environments for builds, tests, experiments, and remote execution. Connect Docker, hosted sandboxes, remote servers, or custom environment providers."
            visual: |
              Codebolt Cloud
                → sandbox A
                → sandbox B
                → remote server
          - title: "Cloud plus self-hosted"
            body: "Use the hosted portal when you want convenience, or self-host Codebolt server when you need control. Both paths keep the same engine model: agents, plugins, memory, routing, and orchestration."
            visual: |
              local server
              self-hosted server
              Codebolt Cloud
              same runtime model

      - type: feature-block
        heading: "Remote agents still connect to your product surfaces"
        body: "Cloud agents can be triggered by webhooks, schedules, chat channels, native apps, and plugins. They can route through the gateway, use persistent memory, call custom agents, and coordinate across environments."
        diagram: |
          webhook / schedule / chat
                   ↓
          Codebolt Gateway
                   ↓
          cloud agent runtime
             ↙      ↓       ↘
          memory  plugins  sandboxes

      - type: cta-block
        heading: "Run agent work where it belongs."
        buttons:
          - { label: "Explore Codebolt Cloud", href: "/products/cloud", variant: "primary" }
          - { label: "Explore Autonomous Agent", href: "/products/autonomous-agent", variant: "secondary" }

  # ── Use Case: Autonomous Companies ─────────
  - slug: "use-cases/autonomous-companies"
    title: "Codebolt Autonomous Company — Build a Business on Agents"
    sections:

      - type: page-header
        title: "Codebolt as Autonomous Company"
        subtitle: "Build entire business domains as plugins. Agents coordinate across all of them. The engine that powers autonomous companies."

      - type: centered-text
        variant: "thesis"
        text: "Every other tool is a single employee. Codebolt is the company. Build engineering, QA, deployment, and monitoring as plugins inside the engine. Each plugin has full access to agentic capabilities. Agents coordinate across all plugins. The provider system scales environments as demand grows."

      - type: feature-block
        heading: "Business domains as plugins"
        body: "Each business function — engineering, testing, deployment, monitoring, customer support — becomes a plugin running inside the engine. Plugins don't need their own agent instances. They execute within the agentic environment with full access to the 63-module SDK, three communication channels, and all coordination primitives."
        diagram: |
          ┌── The Engine ──────────────────┐
          │ Plugin: Engineering            │
          │ Plugin: QA & Testing           │
          │ Plugin: Deployment             │
          │ Plugin: Monitoring             │
          │ Plugin: Customer Support       │
          │ Plugin: Content & Marketing    │
          ├────────────────────────────────┤
          │ Coordinated by stigmergy       │
          │ Governed by guardrails         │
          │ Scaled by provider system      │
          └────────────────────────────────┘

      - type: feature-block
        heading: "Why one engine, not five tools"
        body: "Paperclip orchestrates external agents — Claude Code for coding, OpenClaw for tasks, Cursor for editing. Each tool has its own API limits, its own memory, its own quirks. Codebolt runs everything in one engine. All agents share the same SDK, the same coordination system, the same memory. No integration tax. No tool-switching overhead."
        reverse: true
        diagram: |
          Five tools stitched together:
          Claude Code + OpenClaw + Cursor
          + Paperclip + custom scripts
          = integration nightmare

          One engine:
          Codebolt
          = everything built in
          = everything coordinated
          = everything scales

      - type: feature-block
        heading: "Scale horizontally"
        body: "Start with one local environment. Add Docker containers. Spin up cloud VMs. The provider system treats each as a coordinated environment with full lifecycle management. Git bundles transfer state. Heartbeat monitoring tracks health. As your autonomous company grows, the engine grows with it."
        diagram: |
          Month 1:  1 env, 5 agents
          Month 3:  3 envs, 20 agents
          Month 6:  5 envs, 50 agents
          Year 1:   10 envs, 100+ agents
          All from the same engine

      - type: cta-block
        heading: "Build an autonomous company. On one engine."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Use Cases ──────────────────────────────
  - slug: "use-cases"
    title: "Use Cases — Codebolt"
    sections:

      - type: page-header
        title: "Built for how you work."
        subtitle: "Different teams. Different scales. Same engine."

      - type: card-grid
        heading: "Use case paths"
        cards:
          - title: "Custom Agent Development"
            body: "Build your own agents with custom loops, SDK access, model routing, memory, guardrails, and product-specific behavior."
            href: "/use-cases/custom-agent-development"
          - title: "Autonomous Companies"
            body: "Build business domains as plugins and coordinate agents across engineering, QA, deployment, monitoring, support, and operations."
            href: "/use-cases/autonomous-companies"
          - title: "Coding Agent"
            body: "Use Codebolt for repository-aware coding, tests, reviews, parallel coding threads, and cross-surface software work."
            href: "/use-cases/coding-agent"
          - title: "Agent Cloud"
            body: "Run agents in hosted environments for long-running jobs, sandboxes, webhooks, schedules, and managed remote execution."
            href: "/use-cases/agent-cloud"
          - title: "Agent Orchestration"
            body: "Coordinate many agents across many environments with stigmergy, reviews, merge loops, shared state, and governance."
            href: "/engine/agent-orchestration"

      - type: cta-block
        heading: "Whatever you're building, the engine scales with you."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Architecture ───────────────────────────
  - slug: "architecture"
    title: "Architecture — Codebolt"
    sections:

      - type: page-header
        title: "Architecture"
        subtitle: "Built from the ground up as an agent engine, not an editor with agents bolted on."

      - type: engine-architecture-diagram
        kicker: "ENGINE TOPOLOGY"
        heading: "How everything connects"
        description: "The engine sits at the center. Three communication channels — Agent, Plugin, Client — bridge it to the outside world. Agents run code. Plugins extend the engine itself. Clients give you control through any interface."

      # ─────────────────────────────────────────
      # Subsystem Map (planar)
      # ─────────────────────────────────────────
      - type: subsystem-diagram
        kicker: "SUBSYSTEM MAP"
        title: "CODEBOLT SERVER — 10 ARCHITECTURAL PLANES"
        subtitle: "73 controllers · 134 services · 6 managers · 625+ tools — decomposed by architectural role, not just function"
        planes:
          - label: "EXTERNAL INTERFACE"
            meta: "how the outside world connects to the engine"
            accent: "cyan"
            cards:
              - title: "Client Interface"
                subtitle: "Client SDK"
                tags: ["clientSDK", "REST", "WebSocket"]
                lines:
                  - "72 REST modules + 33 WebSocket modules"
                  - "UIs connect to control the engine"
                  - "Chat, settings, status, agent monitoring"
              - title: "Agent Interface"
                subtitle: "Agent SDK · codeboltjs"
                tags: ["agentSDK", "codeboltjs", "child process"]
                lines:
                  - "63+ API modules available to agents"
                  - "Agents connect as child processes"
                  - "waitForReady() → handle messages → invoke tools"
              - title: "Plugin Interface"
                subtitle: "Plugin SDK"
                tags: ["pluginSDK", "PluginProcessManager", "pluginService"]
                lines:
                  - "WS actions + HTTP REST — no separate agent instance"
                  - "Subscribe to real-time events"
                  - "Runs inside the engine, extends it"
              - title: "Remote Execution Provider"
                subtitle: "Provider · Remote Environments"
                tags: ["providerRegistryService", "environmentsServices"]
                lines:
                  - "Docker provider creates containers running dockerserver"
                  - "Connects back to main instance"
                  - "Git bundle state transfer between environments"
              - title: "Message Gateway"
                subtitle: "internal dispatch"
                tags: ["gateway/", "sockets/", "routes/"]
                lines:
                  - "Routes messages between all four interfaces"
                  - "Channel multiplexer and message router"
                  - "Proxy config for cross-environment routing"
          - label: "AGENT EXECUTION CONTROL"
            meta: "process lifecycle · thread management · remote execution"
            accent: "emerald"
            cards:
              - title: "Agent Process Execution"
                subtitle: "spawn · lifecycle · heartbeat"
                tags: ["AgentProcessManager", "agentService", "agentController"]
                lines:
                  - "Marketplace discovery → cache → spawn as child process"
                  - "find · start · list · details"
                  - "Emits agentExecutionPhase events per phase"
              - title: "Subagent / Side Execution"
                subtitle: "parent → child delegation"
                tags: ["SideExecutionManager", "agentExecutionPhaseDataService"]
                lines:
                  - "Parent run delegates work to child runs"
                  - "Child resumes parent on completion"
                  - "Parent un-waits when all dependencies clear"
              - title: "Background Agent Execution"
                subtitle: "always-on agents"
                tags: ["backgroundAgentController", "localAgents/", "universalAgent/"]
                lines:
                  - "Agents that run continuously without user prompt"
                  - "Local + universal agent directories"
                  - "MCP installer agent for auto-setup"
              - title: "Thread Management"
                subtitle: "10 tools"
                tags: ["agentMessageService", "agentFlowService"]
                lines:
                  - "createThread · createStartThread · createBackgroundThread"
                  - "startThread · updateThread · deleteThread"
                  - "getMessages · updateStatus"
              - title: "Event Queue & Wait"
                subtitle: "6 tools · heartbeat · leases"
                tags: ["agentEventQueueDataService", "agentEventQueueInternal", "HeartbeatManager"]
                lines:
                  - "addEvent · sendAgentMessage · getPendingEvents"
                  - "waitNextEvent · acknowledgeEvent"
                  - "Heartbeat keeps lease alive, detects provider failure"
              - title: "Remote Environment Control"
                subtitle: "lifecycle · state transfer"
                tags: ["environmentRestartService", "shadowGitService"]
                lines:
                  - "CREATED → RUNNING → STOPPED lifecycle"
                  - "Heartbeat monitoring per environment"
                  - "Shadow git bundles for cross-environment transfer"
          - label: "AGENT COORDINATION"
            meta: "multi-agent behavior · swarms · deliberation · reputation"
            accent: "red"
            cards:
              - title: "Swarm & Team Coordination"
                subtitle: "26 tools"
                tags: ["swarmManager", "swarmDataService", "swarmValidation"]
                lines:
                  - "createSwarm · registerAgent · createTeam"
                  - "createRole · assignRole · createVacancy"
                  - "Topology, role + team assignment"
              - title: "Deliberation Council"
                subtitle: "8 tools"
                tags: ["agentDeliberationService", "coordinationService"]
                lines:
                  - "createDeliberation · respondDeliberation"
                  - "voteDeliberation · getWinner"
                  - "Types: decision · review · brainstorm · approval · vote"
              - title: "Agent Portfolio & Karma"
                subtitle: "14 tools · reputation system"
                tags: ["agentPortfolioService", "roleManager", "teamManager"]
                lines:
                  - "getPortfolio · addKarma · getKarmaHistory"
                  - "addTalent · endorseTalent · getRanking"
                  - "addTestimonial · getConversations"
              - title: "Review Merge Request"
                subtitle: "16 tools"
                tags: ["reviewMergeRequestService", "reviewModeService", "problemMatchService"]
                lines:
                  - "createRequest · addFeedback · listRequests"
                  - "Problem matcher seeder for validation"
                  - "Automatic review + merge with pheromone coordination"
          - label: "SYSTEM TOOLS"
            meta: "what agents actually do on the system"
            accent: "emerald"
            cards:
              - title: "Filesystem"
                subtitle: "13 tools"
                tags: ["fileController", "filereadController", "fileReadService"]
                lines:
                  - "readFile · createFile · updateFile · deleteFile"
                  - "searchFiles · grepSearch · listCodeDefinitions"
                  - "readManyFiles for batch operations"
              - title: "Terminal / Shell"
                subtitle: "PTY backed · streaming"
                tags: ["terminalService", "portScannerService", "hostBridge.ts"]
                lines:
                  - "executeCommand · interrupt"
                  - "Streaming stdout/stderr via HostBridge PTY"
                  - "Cross-platform: Electron / CLI / TUI"
              - title: "Git & Shadow Git"
                subtitle: "11 + narrative tools"
                tags: ["gitService", "shadowGitService", "getRepoService"]
                lines:
                  - "init · status · add · commit · diff · push · pull"
                  - "Shadow git for narrative snapshot versioning"
                  - "Git bundles for cross-environment state transfer"
              - title: "Browser Automation"
                subtitle: "12 tools"
                tags: ["browser.navigate", "browser.click", "browser.screenshot"]
                lines:
                  - "navigate · getUrl · close"
                  - "click · type · scroll · enter"
                  - "screenshot · getHtml · getMarkdown · getContent"
              - title: "Code Search & Grep"
                subtitle: "semantic + regex"
                tags: ["codebaseIndexService", "codeUtilsService"]
                lines:
                  - "Semantic code search via embeddings"
                  - "Glob patterns · regex content search"
                  - "Codebase-wide definition listing"
              - title: "Code Utils & Codemap"
                subtitle: "4 + 7 tools"
                tags: ["codeUtilsService", "codemapDataService", "treeSitterService"]
                lines:
                  - "parseCode · analyzeCode · refactorCode · formatCode"
                  - "Codemap: create · get · list · update · save"
                  - "Tree-sitter AST + LSP integration"
          - label: "TOOL EXTENSION"
            meta: "how tools and capabilities extend the engine"
            accent: "amber"
            cards:
              - title: "MCP Implementation"
                subtitle: "4 tools · Model Context Protocol"
                tags: ["mcpService", "toolService", "MCPServers/"]
                lines:
                  - "mcp.execute · configure · listServers · connectServer"
                  - "MCPServers/ directory for registered servers"
                  - "MCP installer agent for auto-discovery"
              - title: "Side Execution & Action Blocks"
                subtitle: "5 + block tools"
                tags: ["SideExecutionManager", "actionBlockRegistry"]
                lines:
                  - "sideExecution.start · stop · status"
                  - "actionBlock.create · execute · list"
                  - "Parallel execution of structured work units"
              - title: "Capabilities & Claims"
                subtitle: "8 tools · feature flags · leases"
                tags: ["capabilityRegistry", "CapabilityManager", "providerRegistryService"]
                lines:
                  - "listCapabilities · startCapability · stopCapability"
                  - "Acquire run_claim — exclusive lock with TTL"
                  - "Release on completion or heartbeat expiry"
              - title: "Skills"
                subtitle: "skill registry"
                tags: ["skillService", "skillController"]
                lines:
                  - "Register and discover agent skills"
                  - "Composable capability building blocks"
                  - "Agents declare and invoke skills"
              - title: "Tool Registry & Search"
                subtitle: "625+ tools · dynamic discovery"
                tags: ["toolService", "extensionService", "pluginService"]
                lines:
                  - "AllTools vs allSearchableTools — scoped per turn"
                  - "ToolSearchEngine for dynamic discovery"
                  - "~30 tools active per turn, 600+ discoverable"
          - label: "INTELLIGENCE"
            meta: "reason · embed · tokenize · local models"
            accent: "amber"
            cards:
              - title: "LLM Inference"
                subtitle: "17+ providers"
                tags: ["llmService", "inference/", "llmController"]
                lines:
                  - "llm.inference · getModelConfig"
                  - "OpenAI · Anthropic · Google · Mistral · Groq · DeepSeek · xAI"
                  - "Per-agent and per-task model selection"
              - title: "Embedding Generation"
                subtitle: "remote + local"
                tags: ["embeddingService", "localEmbeddingService"]
                lines:
                  - "Remote embedding via cloud providers"
                  - "Local embedding via ONNX inference"
                  - "Powers vector DB and codebase search"
              - title: "Tokenization"
                subtitle: "token ops"
                tags: ["tokenizerService"]
                lines:
                  - "tokenizer.countTokens"
                  - "tokenizer.estimateTokens"
                  - "Context window budget calculation"
              - title: "Local Model Management"
                subtitle: "Ollama · LM Studio"
                tags: ["localModelManager", "localModelService", "localModelInferenceService"]
                lines:
                  - "Local model lifecycle management"
                  - "ONNX inference via HostBridge"
                  - "Download, configure, serve local models"
          - label: "MEMORY, KNOWLEDGE & CONTEXT"
            meta: "remember · persist · retrieve · assemble · vector · graph · RAG"
            accent: "purple"
            cards:
              - title: "Context Assembly Engine"
                subtitle: "CAE · 5 tools"
                tags: ["contextAssemblyService", "contextRuleEngineService"]
                lines:
                  - "assemble · validate · evaluateRules"
                  - "Selects relevant memory for each agent turn"
                  - "Rule-driven context window construction"
              - title: "Context Rule Engine"
                subtitle: "7 tools"
                tags: ["contextRuleEngineDataService", "contextRuleEngineService"]
                lines:
                  - "createRules · updateRules · deleteRules"
                  - "evaluateRules · getPossibleVariables"
                  - "Declarative rules for context selection"
              - title: "Episodic Memory"
                subtitle: "append-only · 11 tools"
                tags: ["episodicMemoryDataService"]
                lines:
                  - "createMemory · appendEvent · queryEvents"
                  - "listMemories · archiveMemory"
                  - "Time-series event storage per agent"
              - title: "Persistent Memory"
                subtitle: "structured · 8 tools"
                tags: ["persistentMemoryDataService", "persistentMemoryInstanceService"]
                lines:
                  - "createMemory · getMemory · retrieveMemory"
                  - "Cross-session agent knowledge retention"
                  - "Pipeline service for memory processing"
              - title: "Basic Memory"
                subtitle: "25 tools · JSON / Todo / Markdown"
                tags: ["jsonMemoryService", "markdownMemoryService"]
                lines:
                  - "JSON: save · update · delete · list"
                  - "Todo: save · update · delete · list"
                  - "Markdown: save · update · delete · list"
              - title: "KV Store"
                subtitle: "3 tools"
                tags: ["kvStoreDataService", "kvStoreInstanceService", "kvStoreQueryCompiler"]
                lines:
                  - "createInstance · set · get"
                  - "Query compiler for structured lookups"
                  - "Lightweight key-value persistence"
              - title: "Memory Ingestion & Narrative"
                subtitle: "pipelines · drift · summarization"
                tags: ["memoryIngestionEventBridge", "memoryIngestionExecutionService", "narrativeService"]
                lines:
                  - "createPipeline · executePipeline"
                  - "Events feed episodic + persistent memory"
                  - "Drift detection + narrative summarization"
              - title: "Vector DB"
                subtitle: "sqlite-vec · 4 tools"
                tags: ["vectordbService", "vectordbDataService", "vectordb/"]
                lines:
                  - "addVectorItem · queryVectorItem · queryVectorItems"
                  - "SQLite-vec backed — runs everywhere"
                  - "Powers codebase search and RAG"
              - title: "Knowledge Graph"
                subtitle: "Kuzu · 28 tools"
                tags: ["kgDataService", "kgInstanceService", "kuzuDbService"]
                lines:
                  - "createInstance · addMemoryRecord · addEdge"
                  - "executeView for complex graph queries"
                  - "Kuzu DB for structured relationships"
              - title: "Knowledge Base"
                subtitle: "12 tools · collections · documents"
                tags: ["knowledgeService", "knowledgeDataService", "knowledgeChunkingService"]
                lines:
                  - "createCollection · addDocument · queryKnowledge"
                  - "Chunking service for document processing"
                  - "Update, delete, list collections"
              - title: "RAG Pipeline"
                subtitle: "retrieve · augment"
                tags: ["rag.retrieve", "rag.augment"]
                lines:
                  - "Retrieve relevant context from knowledge stores"
                  - "Augment prompts with retrieved documents"
                  - "Pipeline: chunk → embed → store → retrieve"
          - label: "WORKFLOW & ORCHESTRATION"
            meta: "structured work · DAGs · timing · lifecycle"
            accent: "cyan"
            cards:
              - title: "Jobs & Dependencies"
                subtitle: "13 tools · DAG edges"
                tags: ["jobService", "jobController"]
                lines:
                  - "createJob · updateJob · deleteJob · listJobs"
                  - "addDependency · removeDependency — DAG edges"
                  - "addBid · bidWithdraw · bidAccept · lockJob"
              - title: "Tasks & Activity"
                subtitle: "7 + activity tools"
                tags: ["tasksSevices", "TaskManager", "taskActivityService"]
                lines:
                  - "createTask · updateTask · assignTask · executeTask"
                  - "Task activity tracking and status"
                  - "Task planner for work decomposition"
              - title: "Action Plans & Requirement Plans"
                subtitle: "6 + 9 tools"
                tags: ["actionPlanService", "requirementPlanService", "taskPlannerService"]
                lines:
                  - "actionPlan: create · addTask · startTask · getPlanDetails"
                  - "requirementPlan: sections · reorder · update"
                  - "Requirement → Roadmap → Plan → Block → Todo"
              - title: "Todos & Specs"
                subtitle: "6 + spec tools"
                tags: ["todoService", "specsService"]
                lines:
                  - "createTodo · updateTodo · completeTodo"
                  - "Specs for requirement tracking"
                  - "Simple task lists for lightweight planning"
              - title: "Roadmap & Calendar"
                subtitle: "10 + 8 tools"
                tags: ["roadmapService", "calendarService", "calendarSchedulerService"]
                lines:
                  - "roadmap: phases · features · ideas"
                  - "calendar: events · RSVP · getUpcomingEvents"
                  - "Long-term planning + scheduling"
              - title: "Hooks"
                subtitle: "8 tools · lifecycle triggers"
                tags: ["hooksController", "hooks/"]
                lines:
                  - "createHook · listHooks · getHook · deleteHook"
                  - "hook.initialize for setup"
                  - "Trigger-based automated workflows"
          - label: "COMMUNICATION"
            meta: "chat · mail · channels · notifications"
            accent: "emerald"
            cards:
              - title: "Chat"
                subtitle: "7 tools · user-facing"
                tags: ["chatController", "chatService"]
                lines:
                  - "sendMessage · notify · askQuestion · confirm"
                  - "getHistory · waitForReply · stopProcess"
                  - "User-facing agent messaging interface"
              - title: "Mail"
                subtitle: "23 tools · agent-to-agent"
                tags: ["mailController", "mailService"]
                lines:
                  - "sendMessage · replyMessage · fetchInbox"
                  - "createThread · getThread · summarizeThread"
                  - "Agent registry for message routing"
              - title: "Inbox & Channels"
                subtitle: "integrations · routing"
                tags: ["inboxController", "inboxService", "dynamicPanelService"]
                lines:
                  - "Inbox for agent message routing"
                  - "Dynamic panel service for UI"
                  - "Slack · Discord · Teams · Telegram · WhatsApp"
              - title: "Notifications"
                subtitle: "17 domain services"
                tags: ["applicationEventBus", "eventDataResolverService"]
                lines:
                  - "17 domains: agent · browser · chat · llm · mcp · ..."
                  - "Dispatched via notification handler"
                  - "Broadcasts to UI · plugins · event log"
              - title: "Group Feedback"
                subtitle: "7 tools"
                tags: ["groupFeedback"]
                lines:
                  - "createFeedback · respondFeedback · replyFeedback"
                  - "updateSummary · updateStatus"
                  - "Structured multi-agent feedback loops"
          - label: "GOVERNANCE & INFRASTRUCTURE"
            meta: "platform management · guardrails · testing · state"
            accent: "purple"
            cards:
              - title: "Environment Management"
                subtitle: "13 tools · compute lifecycle"
                tags: ["environmentsServices", "environmentRestartService"]
                lines:
                  - "createEnv · startEnv · stopEnv · restartEnv"
                  - "CREATED → RUNNING → STOPPED lifecycle"
                  - "Docker provider + heartbeat monitoring"
              - title: "Guardrails & Eval"
                subtitle: "rule + LLM evaluation"
                tags: ["guardrailEngine", "guardrailLLMEvaluator", "guardrailRuleEvaluator", "evalService"]
                lines:
                  - "Rule-based guardrail evaluation"
                  - "LLM-based guardrail evaluation"
                  - "Eval service + guardrail data persistence"
              - title: "Auto Testing"
                subtitle: "18 tools"
                tags: ["autoTestingService", "diagnosticService"]
                lines:
                  - "createTestSuite · createTestCase · createTestRun"
                  - "Diagnostic service for issue detection"
                  - "Problem matcher seeder for validation rules"
              - title: "Project & Workspace Structure"
                subtitle: "29 tools"
                tags: ["projectService", "projectStructureService", "workspaceService"]
                lines:
                  - "projectStructure: packages · routes · tables"
                  - "fileUpdateIntent: create · checkOverlap"
                  - "Workspace lifecycle + state management"
              - title: "Settings & State"
                subtitle: "global config"
                tags: ["settingService", "globalSettingsService", "profileService", "userService"]
                lines:
                  - "Global + per-project settings"
                  - "User profiles and authentication"
                  - "Application state management"
              - title: "Themes & Templates"
                subtitle: "appearance · scaffolding"
                tags: ["themeService", "themeSeederService", "templateService", "scaffoldService"]
                lines:
                  - "Theme management and seeding"
                  - "Template service for project templates"
                  - "Scaffold service for project generation"
        stateRail:
          label: "CORE TABLES — STATE ALL PLANES SHARE"
          items:
            - { name: "jobs", desc: "durable work" }
            - { name: "job_dependencies", desc: "DAG edges" }
            - { name: "runs", desc: "executor attempts" }
            - { name: "run_claims", desc: "leases" }
            - { name: "run_dependencies", desc: "wait edges" }
            - { name: "items", desc: "tool calls" }
            - { name: "tool_executions", desc: "results" }
            - { name: "session_messages", desc: "chat" }
            - { name: "usage_ledger", desc: "metering" }
            - { name: "context_assembly", desc: "CAE state" }
            - { name: "event_log", desc: "bus history" }
            - { name: "memory.*", desc: "3-tier memory" }
        footnote: "10 architectural planes · 50 cards · 625+ tools · job is durable work · run is one executor attempt · waits hold a job idle until dependencies clear"

      # ─────────────────────────────────────────
      # Server Execution Model
      # ─────────────────────────────────────────
      - type: structure-diagram
        kicker: "SERVER INTERNALS"
        title: "CODEBOLT SERVER — EXECUTION TOPOLOGY"
        subtitle: "how requests flow from transport to persistence, layer by layer"
        sections:
          - number: "1"
            label: "TRANSPORT LAYER"
            meta: "external requests become routed messages"
            columns: 3
            cards:
              - title: "HTTP Router"
                subtitle: "express.js · 85+ route files"
                accent: "cyan"
                body:
                  - heading: "HANDLES"
                    items:
                      - "REST across 81 domain controllers"
                      - "Auth middleware and CORS"
                      - "Static plugin UI serving"
                  - heading: "ROUTES TO"
                    items:
                      - { type: "ref", text: "controllers/", suffix: "— 81 domain controllers" }
                      - { type: "ref", text: "/pluginui/:pluginId/*", suffix: "— static assets" }
                      - { type: "ref", text: "services/", suffix: "— business logic" }
              - title: "WebSocket Router"
                subtitle: "40+ socket handlers on one endpoint"
                accent: "cyan"
                body:
                  - heading: "MULTIPLEXES"
                    items:
                      - "shell PTY · chat · editor · browser"
                      - "LSP · Monaco · agent debug · knowledge"
                      - "40 independent streams over one WS"
                  - heading: "DISPATCHES VIA"
                    items:
                      - { type: "ref", text: "sockets/handlers/message-router.ts" }
                      - { type: "ref", text: "handlers/message-handlers.ts" }
              - title: "Middleware Chain"
                subtitle: "runs before every handler"
                accent: "cyan"
                body:
                  - heading: "APPLIES"
                    items:
                      - "CORS · body parsing · request logging"
                      - "Auth / tenant scope"
                      - "Error boundary → structured error"
                  - heading: "EMITS"
                    items:
                      - { type: "ref", text: "applicationEventBus", suffix: "— request lifecycle events" }
          - number: "2"
            label: "MESSAGE DISPATCH"
            meta: "transport-agnostic handler layer"
            columns: 3
            cards:
              - title: "CLI Handler Router"
                subtitle: "cliLib · 121 handler files"
                accent: "emerald"
                body:
                  - heading: "ROUTES"
                    items:
                      - "agent · memory · git · terminal · llm"
                      - "vectordb · browser · codemap · knowledge"
                      - "swarm · deliberation · review-merge"
                  - heading: "PATTERN"
                    items:
                      - { type: "numbered", text: "validate input" }
                      - { type: "numbered", text: "call service method" }
                      - { type: "numbered", text: "format response via responseTypes/" }
              - title: "Notification Services"
                subtitle: "17 notification handlers"
                accent: "emerald"
                body:
                  - heading: "CATEGORIES"
                    items:
                      - "agent · browser · chat · fs · git"
                      - "history · job · llm · mcp · memory"
                      - "search · swarm · system · task · terminal"
                  - heading: "DISPATCHES VIA"
                    items:
                      - { type: "ref", text: "notificatinHandler.cli.ts", suffix: "— main router" }
              - title: "Response Types"
                subtitle: "24 type definitions"
                accent: "emerald"
                body:
                  - heading: "NORMALIZES"
                    items:
                      - "Per-domain response shapes"
                      - "Error wrapping + trace context"
                      - "Streaming chunks vs single response"
                  - heading: "ENABLES"
                    items:
                      - { type: "ref", text: "WS", suffix: "· HTTP · IPC transports share logic" }
          - number: "3"
            label: "SERVICE LAYER"
            meta: "business logic · 95+ services"
            columns: 3
            cards:
              - title: "Agent & Execution"
                subtitle: "9 services"
                accent: "amber"
                body:
                  - heading: "CORE SERVICES"
                    items:
                      - { type: "ref", text: "agentService.ts", suffix: "— marketplace sync, YAML parse" }
                      - { type: "ref", text: "agentFlowRuntimeService.ts", suffix: "— flow execution" }
                      - { type: "ref", text: "swarmManager.ts", suffix: "— swarm coordination" }
                      - { type: "ref", text: "agentDeliberationService.ts" }
                      - { type: "ref", text: "agentPortfolioService.ts" }
                  - heading: "MANAGERS"
                    items:
                      - "AgentProcessManager — child process lifecycle"
                      - "CapabilityManager — skill registry"
              - title: "Memory & Context"
                subtitle: "10 services · 3-tier"
                accent: "amber"
                body:
                  - heading: "THREE TIERS"
                    items:
                      - { type: "ref", text: "episodicMemoryDataService", suffix: "— append-only logs" }
                      - { type: "ref", text: "persistentMemoryPipelineService", suffix: "— structured" }
                      - { type: "ref", text: "contextAssemblyService", suffix: "— CAE (1000+ lines)" }
                  - heading: "SUPPORT"
                    items:
                      - "contextRuleEngineService — filter rules"
                      - "memoryIngestionInstanceService — pipelines"
              - title: "Environment & Provider"
                subtitle: "4 services · lifecycle engine"
                accent: "amber"
                body:
                  - heading: "CORE"
                    items:
                      - { type: "ref", text: "environmentsServices.ts", suffix: "— 2500+ lines" }
                      - { type: "ref", text: "providerRegistryService.ts", suffix: "— cloud + local" }
                      - { type: "ref", text: "environmentRestartService.ts" }
                  - heading: "MONITORS VIA"
                    items:
                      - "HeartbeatManager · 10-15s intervals"
                      - "Auto-restart on critical status"
          - number: "4"
            label: "STORAGE LAYER"
            meta: "persistence · platform-agnostic via HostBridge"
            columns: 3
            cards:
              - title: "JSON Stores"
                subtitle: "replaced TypeORM"
                accent: "purple"
                body:
                  - heading: "CONFIG STORES"
                    items:
                      - "workspaceStore · projectStore · themeStore"
                      - "marketplaceAgentStore · marketplaceMcpStore"
                      - "mcpCategoryStore · problemMatcherStore"
                  - heading: "DATA STORES"
                    items:
                      - "appStore · appConfigStore"
                      - { type: "ref", text: "JsonStore", suffix: "— CRUD + filter + sequence" }
              - title: "SQLite (HostBridge)"
                subtitle: "3 databases"
                accent: "purple"
                body:
                  - heading: "DATABASES"
                    items:
                      - "kvStoreDb — key-value"
                      - "eventLogDb — event logging"
                      - "vectorDb — with sqlite-vec extension"
                  - heading: "ACCESS VIA"
                    items:
                      - { type: "ref", text: "hostBridge.sqliteRun/Get/All/Exec" }
              - title: "File System"
                subtitle: "per-project · .codebolt/"
                accent: "purple"
                body:
                  - heading: "DIRECTORIES"
                    items:
                      - "episodic/ — episodic memory files"
                      - "persistent_memory/ — memory definitions"
                      - "rules/ — context rules"
                      - "agentdeliberation/ — deliberation logs"
                  - heading: "GLOBAL"
                    items:
                      - "{userData}/config/ — JSON stores"
                      - "{userData}/data/ — data stores"
        stateRail:
          label: "PERSISTENT STATE RAIL — STORAGE POWERING THE SERVER"
          columns: 6
          items:
            - { name: "workspaceStore", desc: "workspaces" }
            - { name: "projectStore", desc: "projects" }
            - { name: "appStore", desc: "app metadata" }
            - { name: "themeStore", desc: "themes" }
            - { name: "kvStoreDb", desc: "key-value" }
            - { name: "eventLogDb", desc: "event log" }
            - { name: "vectorDb", desc: "embeddings" }
            - { name: "marketplaceAgentStore", desc: "agent marketplace" }
            - { name: "marketplaceMcpStore", desc: "mcp marketplace" }
            - { name: "episodic/", desc: "event logs" }
            - { name: "persistent_memory/", desc: "structured memory" }
            - { name: "rules/", desc: "context rules" }
        distinctions:
          - label: "DISTINCTION"
            text: "Services are transport-agnostic. CLI handlers adapt them to WebSocket / HTTP / IPC without business logic duplication."
          - label: "DISTINCTION"
            text: "HostBridge isolates platform APIs. Electron, CLI, and TUI all implement it — the server runs identically on each."
          - label: "DISTINCTION"
            text: "applicationEventBus persists events to .codebolt/events.json enabling plugin subscriptions and deterministic replay."

      # ─────────────────────────────────────────
      # Agent Execution Flow
      # ─────────────────────────────────────────
      - type: structure-diagram
        kicker: "AGENT RUNTIME"
        title: "AGENT EXECUTION MODEL — ACTOR OWNERSHIP"
        subtitle: "each actor: owns · reads · writes · hands off · emits"
        sections:
          - number: "1"
            label: "CONTROL PLANE"
            meta: "incoming work becomes scheduled execution"
            columns: 2
            cards:
              - title: "Socket Router"
                subtitle: "single WS endpoint · URL-based dispatch"
                accent: "cyan"
                body:
                  - heading: "OWNS"
                    items:
                      - "Parse URL path → select socket handler"
                      - "Maintain connection pool per handler"
                  - heading: "READS"
                    items:
                      - "Incoming WS frames · connection metadata"
                  - heading: "WRITES"
                    items:
                      - { type: "ref", text: "handler.onMessage", suffix: "— dispatched events" }
                  - heading: "HANDOFF"
                    items:
                      - "Message Router → CLI Handler"
              - title: "Agent Service"
                subtitle: "lifecycle + marketplace sync"
                accent: "cyan"
                body:
                  - heading: "OWNS"
                    items:
                      - "Agent discovery, caching, spawn"
                      - "YAML config parsing (remix agents)"
                      - "Agent instance tracking"
                  - heading: "READS"
                    items:
                      - "marketplaceAgentStore · local .codebolt/agents/"
                  - heading: "WRITES"
                    items:
                      - { type: "ref", text: "AgentProcessManager", suffix: "— spawn instruction" }
                  - heading: "HANDOFF"
                    items:
                      - "Agent connects via codeboltjs WebSocket"
          - number: "2"
            label: "EXECUTION PLANE"
            meta: "agent runs · tools execute · responses stream"
            columns: 2
            cards:
              - title: "Agent Process"
                subtitle: "child process · codeboltjs SDK"
                accent: "emerald"
                body:
                  - heading: "OWNS"
                    items:
                      - "Agent logic execution (user code)"
                      - "Tool selection · decision loop"
                      - "Context management per turn"
                  - heading: "READS"
                    items:
                      - "Messages via codebolt.onMessage()"
                      - "63+ SDK modules (fs, git, llm, ...)"
                  - heading: "WRITES"
                    items:
                      - { type: "ref", text: "tool_executions", suffix: "— every tool call" }
                      - { type: "ref", text: "session_messages", suffix: "— assistant output" }
                  - heading: "EMITS"
                    items:
                      - { type: "ref", text: "tool.called", badge: "event" }
                      - { type: "ref", text: "tool.completed", badge: "event" }
              - title: "Tool Executor"
                subtitle: "executeToolService.ts"
                accent: "emerald"
                body:
                  - heading: "OWNS"
                    items:
                      - "Tool resolution against registry"
                      - "Parameter validation + binding"
                      - "Subprocess/PTY/API dispatch"
                  - heading: "READS"
                    items:
                      - "capabilityRegistry · runtime policy"
                      - "MCP-backed tool config"
                  - heading: "WRITES"
                    items:
                      - { type: "ref", text: "items", suffix: "— function_call outputs" }
                      - { type: "ref", text: "tool_executions", suffix: "— call history" }
                  - heading: "HANDOFF"
                    items:
                      - "Results → Agent Process next turn"
          - number: "3"
            label: "SIDE EFFECTS"
            meta: "events fan out after execution"
            columns: 2
            cards:
              - title: "Notification Handlers"
                subtitle: "17 domain-specific handlers"
                accent: "purple"
                body:
                  - heading: "OWNS"
                    items:
                      - "Broadcast events to UI clients"
                      - "Forward to subscribed plugins"
                      - "Persist to event log"
                  - heading: "EMITS"
                    items:
                      - "UI WebSocket stream (realtime)"
                      - "Plugin observers (execution gateway)"
                      - "Chat notifications · system alerts"
              - title: "Execution Gateway"
                subtitle: "pluginLib/executionGatewayHandler.ts"
                accent: "purple"
                body:
                  - heading: "OWNS"
                    items:
                      - "Wrap agent execution with plugin hooks"
                      - "Claims system — per-operation permissions"
                  - heading: "ENABLES"
                    items:
                      - "Plugins observe/modify agent operations"
                      - "Audit trail of every execution"
                      - "Cross-environment proxy execution"
        distinctions:
          - label: "DISTINCTION"
            text: "Agents are child processes — not in-server threads. They connect via WebSocket, giving them identical capabilities whether local or remote."
          - label: "DISTINCTION"
            text: "The execution gateway is plugin-based, not hardcoded. Any plugin can claim it to intercept agent operations — enabling proxy execution across environments."

      # ─────────────────────────────────────────
      # Memory Subsystem
      # ─────────────────────────────────────────
      - type: structure-diagram
        kicker: "MEMORY ARCHITECTURE"
        title: "THREE-TIER MEMORY SUBSYSTEM"
        subtitle: "episodic · persistent · context assembly — how agents remember"
        sections:
          - number: "1"
            label: "EPISODIC MEMORY"
            meta: "raw event logs · append-only"
            columns: 2
            cards:
              - title: "Episodic Memory Service"
                subtitle: "time-based recall"
                accent: "cyan"
                body:
                  - heading: "STORAGE"
                    items:
                      - { type: "ref", text: ".codebolt/memory/episodic/{id}.json" }
                      - "Per-project file per memory thread"
                  - heading: "OPERATIONS"
                    items:
                      - { type: "numbered", text: "createMemory — new thread" }
                      - { type: "numbered", text: "appendEvent — add event to log" }
                      - { type: "numbered", text: "listMemories — get all" }
                      - { type: "numbered", text: "getMemory — get specific" }
                  - heading: "EVENT SHAPE"
                    items:
                      - "{ type, timestamp, content, source, context }"
              - title: "Ingestion Pipeline"
                subtitle: "memoryIngestionInstanceService"
                accent: "cyan"
                body:
                  - heading: "STAGES"
                    items:
                      - { type: "numbered", text: "ingest — raw observation" }
                      - { type: "numbered", text: "enrich — metadata + context" }
                      - { type: "numbered", text: "dedupe — collapse duplicates" }
                      - { type: "numbered", text: "align — schema normalization" }
                  - heading: "FEEDS"
                    items:
                      - "Persistent memory layer (tier 2)"
          - number: "2"
            label: "PERSISTENT MEMORY"
            meta: "structured · pipelined · queryable"
            columns: 2
            cards:
              - title: "Persistent Memory Data"
                subtitle: "persistentMemoryDataService.ts"
                accent: "emerald"
                body:
                  - heading: "STORAGE"
                    items:
                      - { type: "ref", text: ".codebolt/persistent_memory/{id}.json" }
                      - "Named memory types with schemas"
                  - heading: "HANDLES"
                    items:
                      - "Memory definition CRUD"
                      - "Schema validation on write"
                      - "Pipeline specification storage"
              - title: "Pipeline Service"
                subtitle: "persistentMemoryPipelineService.ts"
                accent: "emerald"
                body:
                  - heading: "EXECUTES"
                    items:
                      - "Chunking · embedding generation"
                      - "Retrieval queries · vector search"
                      - "Per-step pipeline execution"
                  - heading: "INTEGRATES"
                    items:
                      - { type: "ref", text: "embeddingService", suffix: "— local ONNX models" }
                      - { type: "ref", text: "vectordbService", suffix: "— sqlite-vec backend" }
          - number: "3"
            label: "CONTEXT ASSEMBLY ENGINE"
            meta: "CAE · selective retrieval with rules"
            columns: 2
            cards:
              - title: "Context Assembly Service"
                subtitle: "1000+ lines · the orchestrator"
                accent: "amber"
                body:
                  - heading: "WORKFLOW"
                    items:
                      - { type: "numbered", text: "Evaluate — assess context rules" }
                      - { type: "numbered", text: "Validate — check required vars" }
                      - { type: "numbered", text: "Execute — run memory pipelines" }
                      - { type: "numbered", text: "Merge — dedupe + normalize" }
                      - { type: "numbered", text: "Contribute — section placement" }
                      - { type: "numbered", text: "Budget — token limits" }
                      - { type: "numbered", text: "Return — assembled context" }
                  - heading: "TRACE"
                    items:
                      - "Every decision logged for audit"
              - title: "Context Rule Engine"
                subtitle: "contextRuleEngineService.ts"
                accent: "amber"
                body:
                  - heading: "RULE STORAGE"
                    items:
                      - { type: "ref", text: ".codebolt/rules/{rule-id}.json" }
                  - heading: "OPERATORS"
                    items:
                      - "eq · ne · in · contains"
                      - "startsWith · endsWith · regex"
                  - heading: "SCOPE VARS"
                    items:
                      - "Evaluated against runtime context"
                      - "Determines which memories to retrieve"
        stateRail:
          label: "MEMORY STATE — WHERE KNOWLEDGE LIVES"
          columns: 5
          items:
            - { name: "episodic/*.json", desc: "event logs" }
            - { name: "persistent_memory/*.json", desc: "definitions + schemas" }
            - { name: "rules/*.json", desc: "context rules" }
            - { name: "vectorDb", desc: "embeddings + search" }
            - { name: "eventLogDb", desc: "execution trace" }
        distinctions:
          - label: "DISTINCTION"
            text: "Episodic ≠ persistent. Episodic is raw append-only observation; persistent is curated, schema-validated knowledge."
          - label: "DISTINCTION"
            text: "The Context Assembly Engine is the only component the agent talks to. It decides what to remember and when — not the agent."

      # ─────────────────────────────────────────
      # Plugin & Environment Subsystem
      # ─────────────────────────────────────────
      - type: structure-diagram
        kicker: "EXTENSION SYSTEM"
        title: "PLUGIN + ENVIRONMENT SUBSYSTEM"
        subtitle: "plugin lifecycle · provider registry · heartbeat monitoring"
        sections:
          - number: "1"
            label: "PLUGIN LIFECYCLE"
            meta: "discover → load → start → running → stop"
            columns: 2
            cards:
              - title: "Plugin Service"
                subtitle: "pluginService.ts · 400+ lines"
                accent: "cyan"
                body:
                  - heading: "DISCOVERS"
                    items:
                      - { type: "ref", text: "~/.codebolt/plugins/", suffix: "— global" }
                      - { type: "ref", text: "{project}/.codeboltPlugins/", suffix: "— per-project" }
                      - "Validates package.json with codebolt.plugin key"
                  - heading: "LIFECYCLE STATES"
                    items:
                      - "Discovered · Loaded · Initialized"
                      - "Started · Stopped · Error"
                  - heading: "AUTO-START TRIGGERS"
                    items:
                      - "On startup · on event · on demand"
              - title: "Plugin Process Manager"
                subtitle: "PluginProcessManager.ts · 300+ lines"
                accent: "cyan"
                body:
                  - heading: "OWNS"
                    items:
                      - "Child process spawning + stdio"
                      - "Signal propagation · timeout mgmt"
                      - "Crash detection + auto-recovery"
                  - heading: "TIMEOUTS"
                    items:
                      - "Spawn 30s · shutdown 5s · force 3s"
                  - heading: "STATUS STATES"
                    items:
                      - "STARTING · RUNNING · STOPPING"
                      - "STOPPED · FAILED · CRASHED"
          - number: "2"
            label: "PLUGIN COMMUNICATION"
            meta: "three simultaneous channels"
            columns: 3
            cards:
              - title: "Channel 1 · WebSocket"
                subtitle: "full-duplex streaming"
                accent: "emerald"
                body:
                  - heading: "USED FOR"
                    items:
                      - "fs · git · terminal · llm calls"
                      - "Same protocol as agents (cliLib)"
                  - heading: "ENDPOINT"
                    items:
                      - { type: "ref", text: "/plugin", suffix: "— server WS" }
              - title: "Channel 2 · Mux Events"
                subtitle: "multiplexed subscriptions"
                accent: "emerald"
                body:
                  - heading: "SUBSCRIBES TO"
                    items:
                      - "task updates · chat events"
                      - "job status · swarm events"
                      - "calendar · review-merge"
                  - heading: "PATTERN"
                    items:
                      - "Event-driven side observer"
              - title: "Channel 3 · HTTP REST"
                subtitle: "CRUD over HTTP"
                accent: "emerald"
                body:
                  - heading: "FOR"
                    items:
                      - "Threads · tasks · projects"
                      - "Knowledge · memory · environments"
                  - heading: "MODULES"
                    items:
                      - "Same 72 REST modules as Client SDK"
          - number: "3"
            label: "ENVIRONMENT + PROVIDER"
            meta: "compute lifecycle · heartbeat · state transfer"
            columns: 2
            cards:
              - title: "Environment Service"
                subtitle: "environmentsServices.ts · 2500+ lines"
                accent: "amber"
                body:
                  - heading: "LIFECYCLE"
                    items:
                      - { type: "arrow", text: "CREATED → STARTING → RUNNING" }
                      - { type: "arrow", text: "STOPPING → STOPPED" }
                      - "Plus: ERROR · UNCONNECTABLE · DISCONNECTED · ARCHIVED"
                  - heading: "EVENTS"
                    items:
                      - "STATE_CHANGED · PROCESS_STARTED"
                      - "HEALTH_CHECK_PASSED/FAILED"
                      - "RESOURCE_CLEANUP"
                  - heading: "STATE TRANSFER"
                    items:
                      - { type: "ref", text: "safeCreateSnapshotArchive" }
                      - { type: "ref", text: "importSnapshotBundle" }
              - title: "Heartbeat Manager"
                subtitle: "managers/HeartbeatManager.ts"
                accent: "amber"
                body:
                  - heading: "CONFIGURATION"
                    items:
                      - "Provider interval: 10s"
                      - "Environment interval: 15s"
                      - "Warning threshold: 2 missed"
                      - "Restart threshold: 3 missed"
                      - "Max restart attempts: 2"
                      - "Restart cooldown: 60s"
                  - heading: "STATUS ESCALATION"
                    items:
                      - { type: "arrow", text: "healthy → warning → critical → dead" }
                  - heading: "ACTIONS"
                    items:
                      - "Auto-restart on critical"
                      - "Emit events · update UI"
        stateRail:
          label: "RUNTIME STATE — PLUGIN + ENVIRONMENT TRACKING"
          columns: 6
          items:
            - { name: "pluginRegistry", desc: "discovered plugins" }
            - { name: "pluginProcesses", desc: "running children" }
            - { name: "environmentRecords", desc: "lifecycle state" }
            - { name: "providerRegistry", desc: "cloud + local" }
            - { name: "heartbeatStatus", desc: "health tracking" }
            - { name: "claimsRegistry", desc: "gateway permissions" }
        distinctions:
          - label: "DISTINCTION"
            text: "Plugins run in separate child processes — crash of one plugin never affects the server or other plugins."
          - label: "DISTINCTION"
            text: "Providers are plugins too. The RemoteExecutionPlugin claims the ExecutionGateway to enable cross-environment agent proxy calls."
          - label: "DISTINCTION"
            text: "Heartbeat is bidirectional: the server pings providers and providers ping the server, so both sides detect failure."

      # ─────────────────────────────────────────
      # Tool / SDK Registry (interactive master-detail)
      # ─────────────────────────────────────────
      - type: tool-registry
        kicker: "AGENT CAPABILITIES"
        title: "TOOL REGISTRY — 66 MODULES · 625+ TOOLS"
        subtitle: "click a category to see its tools · every capability available to an agent"
        groups:
          - number: "1"
            label: "FILE & CODE"
            meta: "codebase read, write, search, analyze"
            columns: 3
            cards:
              - title: "Filesystem"
                subtitle: "codebolt.fs · 13 tools"
                accent: "cyan"
                body:
                  - heading: "READ & WRITE"
                    items:
                      - { type: "ref", text: "fs.readFile" }
                      - { type: "ref", text: "fs.createFile" }
                      - { type: "ref", text: "fs.updateFile" }
                      - { type: "ref", text: "fs.deleteFile" }
                      - { type: "ref", text: "fs.readManyFiles" }
                  - heading: "SEARCH"
                    items:
                      - { type: "ref", text: "fs.searchFiles" }
                      - { type: "ref", text: "fs.grepSearch" }
                      - { type: "ref", text: "fs.listCodeDefinitions" }
              - title: "Git"
                subtitle: "codebolt.git · 11 tools"
                accent: "cyan"
                body:
                  - heading: "VERSIONING"
                    items:
                      - { type: "ref", text: "git.init" }
                      - { type: "ref", text: "git.status" }
                      - { type: "ref", text: "git.add" }
                      - { type: "ref", text: "git.commit" }
                      - { type: "ref", text: "git.diff" }
                  - heading: "REMOTE + BRANCH"
                    items:
                      - { type: "ref", text: "git.push" }
                      - { type: "ref", text: "git.pull" }
                      - { type: "ref", text: "git.checkout" }
                      - { type: "ref", text: "git.branch" }
              - title: "Codebase Search"
                subtitle: "codebolt.codebaseSearch · 2 tools"
                accent: "cyan"
                body:
                  - heading: "SEMANTIC SEARCH"
                    items:
                      - { type: "ref", text: "codebaseSearch.search" }
                      - { type: "ref", text: "codebaseSearch.searchMcpTools" }
              - title: "Code Utils"
                subtitle: "codebolt.codeutils · 4 tools"
                accent: "cyan"
                body:
                  - heading: "AST + ANALYSIS"
                    items:
                      - { type: "ref", text: "codeutils.parseCode" }
                      - { type: "ref", text: "codeutils.analyzeCode" }
                      - { type: "ref", text: "codeutils.refactorCode" }
                      - { type: "ref", text: "codeutils.formatCode" }
              - title: "Codemap"
                subtitle: "codebolt.codemap · 7 tools"
                accent: "cyan"
                body:
                  - heading: "CODE MAPPING"
                    items:
                      - { type: "ref", text: "codemap.create" }
                      - { type: "ref", text: "codemap.get" }
                      - { type: "ref", text: "codemap.list" }
                      - { type: "ref", text: "codemap.update" }
                      - { type: "ref", text: "codemap.delete" }
                      - { type: "ref", text: "codemap.save" }
          - number: "2"
            label: "EXECUTION"
            meta: "run code · control browsers · call tools"
            columns: 3
            cards:
              - title: "Terminal / Shell"
                subtitle: "codebolt.terminal · PTY backed"
                accent: "emerald"
                body:
                  - heading: "COMMANDS"
                    items:
                      - { type: "ref", text: "terminal.executeCommand" }
                      - { type: "ref", text: "terminal.interrupt" }
                  - heading: "BACKING"
                    items:
                      - "HostBridge PTY · streaming stdout/stderr"
                      - "Cross-platform (Electron / CLI / TUI)"
              - title: "Browser Automation"
                subtitle: "codebolt.browser · 12 tools"
                accent: "emerald"
                body:
                  - heading: "NAVIGATION"
                    items:
                      - { type: "ref", text: "browser.navigate" }
                      - { type: "ref", text: "browser.getUrl" }
                      - { type: "ref", text: "browser.close" }
                  - heading: "INTERACTION"
                    items:
                      - { type: "ref", text: "browser.click" }
                      - { type: "ref", text: "browser.type" }
                      - { type: "ref", text: "browser.scroll" }
                      - { type: "ref", text: "browser.enter" }
                  - heading: "CAPTURE"
                    items:
                      - { type: "ref", text: "browser.screenshot" }
                      - { type: "ref", text: "browser.getHtml", suffix: "· getMarkdown · getContent" }
              - title: "MCP"
                subtitle: "codebolt.mcp · model context protocol · 4 tools"
                accent: "emerald"
                body:
                  - heading: "MCP TOOLS"
                    items:
                      - { type: "ref", text: "mcp.execute" }
                      - { type: "ref", text: "mcp.configure" }
                      - { type: "ref", text: "mcp.listServers" }
                      - { type: "ref", text: "mcp.connectServer" }
              - title: "Side Execution"
                subtitle: "codebolt.sideExecution · parallel work · 5 tools"
                accent: "emerald"
                body:
                  - heading: "SIDE EXECUTION"
                    items:
                      - { type: "ref", text: "sideExecution.start" }
                      - { type: "ref", text: "sideExecution.stop" }
                      - { type: "ref", text: "sideExecution.status" }
                      - { type: "ref", text: "sideExecution.listActionBlocks" }
                  - heading: "ACTION BLOCKS"
                    items:
                      - { type: "ref", text: "actionBlock.create" }
                      - { type: "ref", text: "actionBlock.execute" }
                      - { type: "ref", text: "actionBlock.list" }
          - number: "3"
            label: "INTELLIGENCE"
            meta: "reason · retrieve · embed · query"
            columns: 3
            cards:
              - title: "LLM"
                subtitle: "codebolt.llm · 17+ providers"
                accent: "amber"
                body:
                  - heading: "INFERENCE"
                    items:
                      - { type: "ref", text: "llm.inference" }
                      - { type: "ref", text: "llm.getModelConfig" }
                  - heading: "PROVIDERS"
                    items:
                      - "OpenAI · Anthropic · Google"
                      - "Mistral · Groq · DeepSeek · xAI"
                      - "Ollama · LM Studio (local)"
                  - heading: "TOKEN OPS"
                    items:
                      - { type: "ref", text: "tokenizer.countTokens" }
                      - { type: "ref", text: "tokenizer.estimateTokens" }
              - title: "Vector DB"
                subtitle: "codebolt.vectordb · sqlite-vec · 4 tools"
                accent: "amber"
                body:
                  - heading: "VECTOR OPS"
                    items:
                      - { type: "ref", text: "vectordb.addVectorItem" }
                      - { type: "ref", text: "vectordb.queryVectorItem" }
                      - { type: "ref", text: "vectordb.queryVectorItems" }
                      - { type: "ref", text: "vectordb.getVector" }
              - title: "RAG"
                subtitle: "codebolt.rag · retrieval-augmented · 2 tools"
                accent: "amber"
                body:
                  - heading: "RAG PIPELINE"
                    items:
                      - { type: "ref", text: "rag.retrieve" }
                      - { type: "ref", text: "rag.augment" }
              - title: "Knowledge Graph"
                subtitle: "codebolt.kg · 28 tools · Kuzu backed"
                accent: "amber"
                body:
                  - heading: "INSTANCES"
                    items:
                      - { type: "ref", text: "kg.createInstanceTemplate" }
                      - { type: "ref", text: "kg.createInstance" }
                      - { type: "ref", text: "kg.getInstance" }
                  - heading: "GRAPH OPS"
                    items:
                      - { type: "ref", text: "kg.addMemoryRecord" }
                      - { type: "ref", text: "kg.addEdge" }
                      - { type: "ref", text: "kg.listMemoryRecords" }
                      - { type: "ref", text: "kg.executeView" }
              - title: "Knowledge Base"
                subtitle: "codebolt.knowledge · 12 tools"
                accent: "amber"
                body:
                  - heading: "COLLECTIONS"
                    items:
                      - { type: "ref", text: "knowledge.createCollection" }
                      - { type: "ref", text: "knowledge.listCollections" }
                      - { type: "ref", text: "knowledge.getCollection" }
                      - { type: "ref", text: "knowledge.deleteCollection" }
                  - heading: "DOCUMENTS"
                    items:
                      - { type: "ref", text: "knowledge.addDocument" }
                      - { type: "ref", text: "knowledge.queryKnowledge" }
                      - { type: "ref", text: "knowledge.updateDocument" }
          - number: "4"
            label: "MEMORY & CONTEXT"
            meta: "remember · persist · assemble · retrieve"
            columns: 3
            cards:
              - title: "Basic Memory"
                subtitle: "codebolt.memory · 25 tools · JSON/Todo/Markdown"
                accent: "purple"
                body:
                  - heading: "JSON STORE"
                    items:
                      - { type: "ref", text: "memory.jsonSave" }
                      - { type: "ref", text: "memory.jsonUpdate" }
                      - { type: "ref", text: "memory.jsonDelete" }
                      - { type: "ref", text: "memory.jsonList" }
                  - heading: "TODO STORE"
                    items:
                      - { type: "ref", text: "memory.todoSave" }
                      - { type: "ref", text: "memory.todoUpdate", suffix: "· delete · list" }
                  - heading: "MARKDOWN STORE"
                    items:
                      - { type: "ref", text: "memory.markdownSave" }
                      - { type: "ref", text: "memory.markdownUpdate", suffix: "· delete · list" }
              - title: "Episodic Memory"
                subtitle: "append-only event logs · 11 tools"
                accent: "purple"
                body:
                  - heading: "MEMORY OPS"
                    items:
                      - { type: "ref", text: "episodicMemory.createMemory" }
                      - { type: "ref", text: "episodicMemory.appendEvent" }
                      - { type: "ref", text: "episodicMemory.queryEvents" }
                      - { type: "ref", text: "episodicMemory.listMemories" }
                      - { type: "ref", text: "episodicMemory.archiveMemory" }
              - title: "Persistent Memory"
                subtitle: "codebolt.persistentMemory · structured · 8 tools"
                accent: "purple"
                body:
                  - heading: "MEMORY OPS"
                    items:
                      - { type: "ref", text: "persistentMemory.createMemory" }
                      - { type: "ref", text: "persistentMemory.getMemory" }
                      - { type: "ref", text: "persistentMemory.listMemories" }
                      - { type: "ref", text: "persistentMemory.updateMemory" }
                      - { type: "ref", text: "persistentMemory.retrieveMemory" }
              - title: "Memory Ingestion"
                subtitle: "codebolt.memoryIngestion · pipelines · 2 tools"
                accent: "purple"
                body:
                  - heading: "PIPELINES"
                    items:
                      - { type: "ref", text: "memoryIngestion.createPipeline" }
                      - { type: "ref", text: "memoryIngestion.executePipeline" }
              - title: "Context Assembly"
                subtitle: "codebolt.contextAssembly · CAE · 5 tools"
                accent: "purple"
                body:
                  - heading: "ASSEMBLY"
                    items:
                      - { type: "ref", text: "contextAssembly.assemble" }
                      - { type: "ref", text: "contextAssembly.validate" }
                      - { type: "ref", text: "contextAssembly.getMemoryTypes" }
                      - { type: "ref", text: "contextAssembly.evaluateRules" }
                      - { type: "ref", text: "contextAssembly.getRequiredVariables" }
              - title: "Context Rule Engine"
                subtitle: "codebolt.contextRuleEngine · 7 tools"
                accent: "purple"
                body:
                  - heading: "RULES"
                    items:
                      - { type: "ref", text: "contextRuleEngine.createRules" }
                      - { type: "ref", text: "contextRuleEngine.updateRules" }
                      - { type: "ref", text: "contextRuleEngine.deleteRules" }
                      - { type: "ref", text: "contextRuleEngine.listRules" }
                      - { type: "ref", text: "contextRuleEngine.evaluateRules" }
                      - { type: "ref", text: "contextRuleEngine.getPossibleVariables" }
              - title: "KV Store"
                subtitle: "codebolt.kvStore · key-value · 3 tools"
                accent: "purple"
                body:
                  - heading: "KEY-VALUE"
                    items:
                      - { type: "ref", text: "kvStore.createInstance" }
                      - { type: "ref", text: "kvStore.set" }
                      - { type: "ref", text: "kvStore.get" }
              - title: "Event Log"
                subtitle: "codebolt.eventLog · 9 tools"
                accent: "purple"
                body:
                  - heading: "EVENTS"
                    items:
                      - { type: "ref", text: "eventLog.createInstance" }
                      - { type: "ref", text: "eventLog.appendEvent" }
                      - { type: "ref", text: "eventLog.appendEvents" }
                      - { type: "ref", text: "eventLog.queryEvents" }
                      - { type: "ref", text: "eventLog.getStats" }
          - number: "5"
            label: "AGENT COORDINATION"
            meta: "spawn · coordinate · delegate · review"
            columns: 3
            cards:
              - title: "Agent"
                subtitle: "codebolt.agent · lifecycle · 4 tools"
                accent: "red"
                body:
                  - heading: "AGENT OPS"
                    items:
                      - { type: "ref", text: "agent.find" }
                      - { type: "ref", text: "agent.start" }
                      - { type: "ref", text: "agent.list" }
                      - { type: "ref", text: "agent.details" }
              - title: "Threads"
                subtitle: "codebolt.thread · execution threads · 10 tools"
                accent: "red"
                body:
                  - heading: "THREAD OPS"
                    items:
                      - { type: "ref", text: "thread.createThread" }
                      - { type: "ref", text: "thread.createStartThread" }
                      - { type: "ref", text: "thread.createBackgroundThread" }
                      - { type: "ref", text: "thread.listThreads" }
                      - { type: "ref", text: "thread.getThread" }
                      - { type: "ref", text: "thread.startThread" }
                      - { type: "ref", text: "thread.updateThread" }
                      - { type: "ref", text: "thread.deleteThread" }
                      - { type: "ref", text: "thread.getMessages" }
                      - { type: "ref", text: "thread.updateStatus" }
              - title: "Background Threads"
                subtitle: "codebolt.backgroundChildThreads · 4 tools"
                accent: "red"
                body:
                  - heading: "CHILD THREADS"
                    items:
                      - { type: "ref", text: "backgroundChildThreads.start" }
                      - { type: "ref", text: "backgroundChildThreads.stop" }
                      - { type: "ref", text: "backgroundChildThreads.status" }
                      - { type: "ref", text: "backgroundChildThreads.list" }
              - title: "Swarm"
                subtitle: "multi-agent coordination · 26 tools"
                accent: "red"
                body:
                  - heading: "SWARMS"
                    items:
                      - { type: "ref", text: "swarm.createSwarm" }
                      - { type: "ref", text: "swarm.registerAgent" }
                  - heading: "TEAMS + ROLES"
                    items:
                      - { type: "ref", text: "swarm.createTeam" }
                      - { type: "ref", text: "swarm.joinTeam" }
                      - { type: "ref", text: "swarm.createRole" }
                      - { type: "ref", text: "swarm.assignRole" }
                  - heading: "VACANCIES"
                    items:
                      - { type: "ref", text: "swarm.createVacancy" }
                      - { type: "ref", text: "swarm.applyVacancy" }
              - title: "Agent Deliberation"
                subtitle: "codebolt.agentDeliberation · voting · 8 tools"
                accent: "red"
                body:
                  - heading: "DELIBERATION"
                    items:
                      - { type: "ref", text: "agentDeliberation.createDeliberation" }
                      - { type: "ref", text: "agentDeliberation.getDeliberation" }
                      - { type: "ref", text: "agentDeliberation.listDeliberations" }
                      - { type: "ref", text: "agentDeliberation.updateDeliberation" }
                      - { type: "ref", text: "agentDeliberation.respondDeliberation" }
                      - { type: "ref", text: "agentDeliberation.voteDeliberation" }
                      - { type: "ref", text: "agentDeliberation.getWinner" }
              - title: "Review Merge"
                subtitle: "codebolt.reviewMergeRequest · 16 tools"
                accent: "red"
                body:
                  - heading: "REVIEW REQUESTS"
                    items:
                      - { type: "ref", text: "reviewMergeRequest.createRequest" }
                      - { type: "ref", text: "reviewMergeRequest.getRequest" }
                      - { type: "ref", text: "reviewMergeRequest.listRequests" }
                      - { type: "ref", text: "reviewMergeRequest.updateRequest" }
                      - { type: "ref", text: "reviewMergeRequest.addFeedback" }
              - title: "Agent Portfolio"
                subtitle: "codebolt.agentPortfolio · reputation · 14 tools"
                accent: "red"
                body:
                  - heading: "PORTFOLIO"
                    items:
                      - { type: "ref", text: "agentPortfolio.getPortfolio" }
                      - { type: "ref", text: "agentPortfolio.getConversations" }
                      - { type: "ref", text: "agentPortfolio.updateProfile" }
                  - heading: "KARMA + TALENTS"
                    items:
                      - { type: "ref", text: "agentPortfolio.addKarma" }
                      - { type: "ref", text: "agentPortfolio.getKarmaHistory" }
                      - { type: "ref", text: "agentPortfolio.addAppreciation" }
                      - { type: "ref", text: "agentPortfolio.addTalent" }
                      - { type: "ref", text: "agentPortfolio.endorseTalent" }
                      - { type: "ref", text: "agentPortfolio.getTalents" }
                      - { type: "ref", text: "agentPortfolio.getRanking" }
                  - heading: "TESTIMONIALS"
                    items:
                      - { type: "ref", text: "agentPortfolio.addTestimonial" }
                      - { type: "ref", text: "agentPortfolio.updateTestimonial" }
                      - { type: "ref", text: "agentPortfolio.deleteTestimonial" }
              - title: "Agent Event Queue"
                subtitle: "codebolt.agentEventQueue · 6 tools"
                accent: "red"
                body:
                  - heading: "EVENTS"
                    items:
                      - { type: "ref", text: "agentEventQueue.addEvent" }
                      - { type: "ref", text: "agentEventQueue.sendAgentMessage" }
                      - { type: "ref", text: "agentEventQueue.getPendingEvents" }
                      - { type: "ref", text: "agentEventQueue.getStats" }
                  - heading: "WAIT + ACK"
                    items:
                      - { type: "ref", text: "agentEventQueue.waitNextEvent" }
                      - { type: "ref", text: "agentEventQueue.acknowledgeEvent" }
          - number: "6"
            label: "WORKFLOW & PLANNING"
            meta: "structured work · timing · hooks"
            columns: 3
            cards:
              - title: "Tasks"
                subtitle: "codebolt.task · task management · 7 tools"
                accent: "cyan"
                body:
                  - heading: "TASK OPS"
                    items:
                      - { type: "ref", text: "task.createTask" }
                      - { type: "ref", text: "task.updateTask" }
                      - { type: "ref", text: "task.deleteTask" }
                      - { type: "ref", text: "task.getTask" }
                      - { type: "ref", text: "task.listTasks" }
                      - { type: "ref", text: "task.assignTask" }
                      - { type: "ref", text: "task.executeTask" }
              - title: "Jobs"
                subtitle: "codebolt.job · parallel work · 13 tools"
                accent: "cyan"
                body:
                  - heading: "JOB OPS"
                    items:
                      - { type: "ref", text: "job.createJob" }
                      - { type: "ref", text: "job.getJob" }
                      - { type: "ref", text: "job.updateJob" }
                      - { type: "ref", text: "job.deleteJob" }
                      - { type: "ref", text: "job.listJobs" }
                      - { type: "ref", text: "job.createJobGroup" }
                  - heading: "DEPENDENCIES"
                    items:
                      - { type: "ref", text: "job.addDependency" }
                      - { type: "ref", text: "job.removeDependency" }
                  - heading: "BIDDING + LOCKING"
                    items:
                      - { type: "ref", text: "job.addBid" }
                      - { type: "ref", text: "job.bidWithdraw" }
                      - { type: "ref", text: "job.bidAccept" }
                      - { type: "ref", text: "job.lockJob" }
                      - { type: "ref", text: "job.unlockJob" }
              - title: "Action Plans"
                subtitle: "codebolt.actionPlan · structured planning · 6 tools"
                accent: "cyan"
                body:
                  - heading: "PLAN OPS"
                    items:
                      - { type: "ref", text: "actionPlan.createPlan" }
                      - { type: "ref", text: "actionPlan.addTask" }
                      - { type: "ref", text: "actionPlan.startTask" }
                      - { type: "ref", text: "actionPlan.updatePlan" }
                      - { type: "ref", text: "actionPlan.getPlanDetails" }
                      - { type: "ref", text: "actionPlan.getAllPlans" }
              - title: "Todos"
                subtitle: "codebolt.todo · simple task lists · 6 tools"
                accent: "cyan"
                body:
                  - heading: "TODO OPS"
                    items:
                      - { type: "ref", text: "todo.createTodo" }
                      - { type: "ref", text: "todo.updateTodo" }
                      - { type: "ref", text: "todo.deleteTodo" }
                      - { type: "ref", text: "todo.getTodo" }
                      - { type: "ref", text: "todo.listTodos" }
                      - { type: "ref", text: "todo.completeTodo" }
              - title: "Requirement Plans"
                subtitle: "codebolt.requirementPlan · specs · 9 tools"
                accent: "cyan"
                body:
                  - heading: "PLAN OPS"
                    items:
                      - { type: "ref", text: "requirementPlan.createPlan" }
                      - { type: "ref", text: "requirementPlan.getPlan" }
                      - { type: "ref", text: "requirementPlan.updatePlan" }
                      - { type: "ref", text: "requirementPlan.listPlans" }
                  - heading: "SECTIONS"
                    items:
                      - { type: "ref", text: "requirementPlan.addSection" }
                      - { type: "ref", text: "requirementPlan.updateSection" }
                      - { type: "ref", text: "requirementPlan.removeSection" }
                      - { type: "ref", text: "requirementPlan.reorderSections" }
              - title: "Calendar"
                subtitle: "codebolt.calendar · scheduling · 8 tools"
                accent: "cyan"
                body:
                  - heading: "EVENT OPS"
                    items:
                      - { type: "ref", text: "calendar.createEvent" }
                      - { type: "ref", text: "calendar.updateEvent" }
                      - { type: "ref", text: "calendar.deleteEvent" }
                      - { type: "ref", text: "calendar.getEvent" }
                      - { type: "ref", text: "calendar.listEvents" }
                      - { type: "ref", text: "calendar.getEventsInRange" }
                      - { type: "ref", text: "calendar.getUpcomingEvents" }
                  - heading: "STATUS"
                    items:
                      - { type: "ref", text: "calendar.markEventComplete" }
                      - { type: "ref", text: "calendar.rsvpEvent" }
              - title: "Roadmap"
                subtitle: "codebolt.roadmap · long-term planning · 10 tools"
                accent: "cyan"
                body:
                  - heading: "PHASES + FEATURES"
                    items:
                      - { type: "ref", text: "roadmap.createPhase" }
                      - { type: "ref", text: "roadmap.updatePhase" }
                      - { type: "ref", text: "roadmap.createFeature" }
                      - { type: "ref", text: "roadmap.updateFeature" }
                      - { type: "ref", text: "roadmap.getFeatures" }
                      - { type: "ref", text: "roadmap.getPhases" }
                      - { type: "ref", text: "roadmap.getRoadmap" }
                  - heading: "IDEAS"
                    items:
                      - { type: "ref", text: "roadmap.createIdea" }
                      - { type: "ref", text: "roadmap.getIdeas" }
                      - { type: "ref", text: "roadmap.reviewIdea" }
              - title: "Hooks"
                subtitle: "codebolt.hook · lifecycle triggers · 8 tools"
                accent: "cyan"
                body:
                  - heading: "HOOK OPS"
                    items:
                      - { type: "ref", text: "hook.createHook" }
                      - { type: "ref", text: "hook.listHooks" }
                      - { type: "ref", text: "hook.getHook" }
                      - { type: "ref", text: "hook.deleteHook" }
                      - { type: "ref", text: "hook.initialize" }
          - number: "7"
            label: "COMMUNICATION"
            meta: "chat · agent-to-agent · notifications"
            columns: 3
            cards:
              - title: "Chat"
                subtitle: "user-facing messaging · 7 tools"
                accent: "emerald"
                body:
                  - heading: "OUTBOUND"
                    items:
                      - { type: "ref", text: "chat.sendMessage" }
                      - { type: "ref", text: "chat.notify" }
                      - { type: "ref", text: "chat.askQuestion" }
                      - { type: "ref", text: "chat.confirm" }
                  - heading: "HISTORY + CONTROL"
                    items:
                      - { type: "ref", text: "chat.getHistory" }
                      - { type: "ref", text: "chat.waitForReply" }
                      - { type: "ref", text: "chat.stopProcess" }
              - title: "Mail"
                subtitle: "agent-to-agent · 23 tools"
                accent: "emerald"
                body:
                  - heading: "MESSAGES"
                    items:
                      - { type: "ref", text: "mail.sendMessage" }
                      - { type: "ref", text: "mail.replyMessage" }
                      - { type: "ref", text: "mail.fetchInbox" }
                  - heading: "THREADS"
                    items:
                      - { type: "ref", text: "mail.createThread" }
                      - { type: "ref", text: "mail.getThread" }
                      - { type: "ref", text: "mail.summarizeThread" }
                  - heading: "REGISTRY"
                    items:
                      - { type: "ref", text: "mail.registerAgent" }
                      - { type: "ref", text: "mail.listAgents" }
              - title: "Channels"
                subtitle: "codebolt.channel · team chat integrations"
                accent: "emerald"
                body:
                  - heading: "CHANNEL OPS"
                    items:
                      - { type: "ref", text: "channel.createChannel" }
                      - { type: "ref", text: "channel.listChannels" }
                      - { type: "ref", text: "channel.sendMessage" }
                  - heading: "PLATFORMS"
                    items:
                      - "Slack · Discord · Teams"
                      - "Telegram · WhatsApp"
              - title: "Group Feedback"
                subtitle: "codebolt.groupFeedback · 7 tools"
                accent: "emerald"
                body:
                  - heading: "FEEDBACK OPS"
                    items:
                      - { type: "ref", text: "groupFeedback.createFeedback" }
                      - { type: "ref", text: "groupFeedback.getFeedback" }
                      - { type: "ref", text: "groupFeedback.listFeedback" }
                      - { type: "ref", text: "groupFeedback.respondFeedback" }
                      - { type: "ref", text: "groupFeedback.replyFeedback" }
                      - { type: "ref", text: "groupFeedback.updateSummary" }
                      - { type: "ref", text: "groupFeedback.updateStatus" }
          - number: "8"
            label: "EXTENSIBILITY & ADMIN"
            meta: "orchestration · environments · testing · capabilities"
            columns: 3
            cards:
              - title: "Project Structure"
                subtitle: "29 tools · the biggest category"
                accent: "purple"
                body:
                  - heading: "PACKAGES"
                    items:
                      - { type: "ref", text: "projectStructure.createPackage" }
                      - { type: "ref", text: "projectStructure.listPackages" }
                      - { type: "ref", text: "projectStructure.addDependency" }
                  - heading: "SCHEMA"
                    items:
                      - { type: "ref", text: "projectStructure.addRoute" }
                      - { type: "ref", text: "projectStructure.addTable" }
                  - heading: "INTENTS"
                    items:
                      - { type: "ref", text: "fileUpdateIntent.createIntent" }
                      - { type: "ref", text: "fileUpdateIntent.checkOverlap" }
              - title: "Environment"
                subtitle: "codebolt.environment · compute lifecycle · 13 tools"
                accent: "purple"
                body:
                  - heading: "ENV OPS"
                    items:
                      - { type: "ref", text: "environment.createEnv" }
                      - { type: "ref", text: "environment.getEnv" }
                      - { type: "ref", text: "environment.listEnvs" }
                      - { type: "ref", text: "environment.updateEnv" }
                      - { type: "ref", text: "environment.deleteEnv" }
                  - heading: "LIFECYCLE"
                    items:
                      - { type: "ref", text: "environment.startEnv" }
                      - { type: "ref", text: "environment.stopEnv" }
                      - { type: "ref", text: "environment.restartEnv" }
                      - { type: "ref", text: "environment.getStatus" }
                      - { type: "ref", text: "environment.getProviders" }
              - title: "Orchestrator"
                subtitle: "codebolt.orchestrator · workflow · 8 tools"
                accent: "purple"
                body:
                  - heading: "ORCHESTRATOR OPS"
                    items:
                      - { type: "ref", text: "orchestrator.createOrchestrator" }
                      - { type: "ref", text: "orchestrator.getOrchestrator" }
                      - { type: "ref", text: "orchestrator.listOrchestrators" }
                      - { type: "ref", text: "orchestrator.updateOrchestrator" }
                      - { type: "ref", text: "orchestrator.deleteOrchestrator" }
                  - heading: "SETTINGS"
                    items:
                      - { type: "ref", text: "orchestrator.getSettings" }
                      - { type: "ref", text: "orchestrator.updateSettings" }
                      - { type: "ref", text: "orchestrator.updateStatus" }
              - title: "Auto Testing"
                subtitle: "codebolt.autoTesting · test framework · 18 tools"
                accent: "purple"
                body:
                  - heading: "TEST SUITES"
                    items:
                      - { type: "ref", text: "autoTesting.createTestSuite" }
                      - { type: "ref", text: "autoTesting.listTestSuites" }
                  - heading: "TEST CASES"
                    items:
                      - { type: "ref", text: "autoTesting.createTestCase" }
                      - { type: "ref", text: "autoTesting.listTestCases" }
                  - heading: "TEST RUNS"
                    items:
                      - { type: "ref", text: "autoTesting.createTestRun" }
                      - { type: "ref", text: "autoTesting.updateTestRun" }
              - title: "Capability"
                subtitle: "codebolt.capability · feature flags · 8 tools"
                accent: "purple"
                body:
                  - heading: "CAPABILITY OPS"
                    items:
                      - { type: "ref", text: "capability.listCapabilities" }
                      - { type: "ref", text: "capability.getCapabilityDetail" }
                      - { type: "ref", text: "capability.startCapability" }
                      - { type: "ref", text: "capability.stopCapability" }
                      - { type: "ref", text: "capability.getExecutionStatus" }
              - title: "State"
                subtitle: "codebolt.state · state management · 5 tools"
                accent: "purple"
                body:
                  - heading: "STATE OPS"
                    items:
                      - { type: "ref", text: "state.setState" }
                      - { type: "ref", text: "state.getState" }
                      - { type: "ref", text: "state.updateState" }
                      - { type: "ref", text: "state.deleteState" }
                      - { type: "ref", text: "state.listStates" }
              - title: "Debug"
                subtitle: "codebolt.debug · introspection · 2 tools"
                accent: "purple"
                body:
                  - heading: "DEBUG OPS"
                    items:
                      - { type: "ref", text: "debug.log" }
                      - { type: "ref", text: "debug.getDebugInfo" }
          - number: "9"
            label: "UTILITIES & INTERNALS"
            meta: "web crawling · notifications · low-level search · messaging"
            columns: 3
            cards:
              - title: "Crawler"
                subtitle: "codebolt.crawler · 5 tools"
                accent: "default"
                body:
                  - heading: "WEB CRAWLING"
                    items:
                      - { type: "ref", text: "crawler.crawl" }
                      - { type: "ref", text: "crawler.extractContent" }
                      - { type: "ref", text: "crawler.extractLinks" }
                      - { type: "ref", text: "crawler.getMetadata" }
                      - { type: "ref", text: "crawler.stopCrawl" }
              - title: "User Message Manager"
                subtitle: "message primitives · 10 tools"
                accent: "default"
                body:
                  - heading: "MESSAGE OPS"
                    items:
                      - { type: "ref", text: "userMessage.create" }
                      - { type: "ref", text: "userMessage.append" }
                      - { type: "ref", text: "userMessage.getHistory" }
                      - { type: "ref", text: "userMessage.clear" }
                  - heading: "UTILITIES"
                    items:
                      - { type: "ref", text: "userMessageUtils.format" }
                      - { type: "ref", text: "userMessageUtils.parse" }
                      - { type: "ref", text: "userMessageUtils.merge" }
              - title: "Search Internals"
                subtitle: "tools/search/ · 9 low-level tools"
                accent: "default"
                body:
                  - heading: "PATTERNS"
                    items:
                      - { type: "ref", text: "Glob", suffix: "— glob patterns" }
                      - { type: "ref", text: "Grep", suffix: "— regex content" }
                      - { type: "ref", text: "SearchFiles" }
                  - heading: "CODEBASE"
                    items:
                      - { type: "ref", text: "CodebaseSearch" }
                      - { type: "ref", text: "ListCodeDefinitionNames" }
                      - { type: "ref", text: "SearchMcpTool" }
                  - heading: "NOTE"
                    items:
                      - "Exposed via fs.grepSearch and fs.searchFiles"
              - title: "Notifications"
                subtitle: "17 domain notification services"
                accent: "default"
                body:
                  - heading: "DOMAINS"
                    items:
                      - "agent · browser · chat · codeutils"
                      - "crawler · dbmemory · fs · git · history"
                      - "llm · mcp · memory · search"
                      - "swarm · system · task · terminal"
                  - heading: "DISPATCHED VIA"
                    items:
                      - { type: "ref", text: "notificatinHandler.cli.ts", suffix: "— main router" }
                  - heading: "BROADCASTS TO"
                    items:
                      - "UI clients · subscribed plugins · event log"

      - type: stat-grid
        tone: "muted"
        columns: 4
        stats:
          - { label: "FILE & CODE", value: "45" }
          - { label: "EXECUTION", value: "25" }
          - { label: "INTELLIGENCE", value: "61" }
          - { label: "MEMORY & CONTEXT", value: "87" }
          - { label: "AGENT COORDINATION", value: "94" }
          - { label: "WORKFLOW & PLANNING", value: "65" }
          - { label: "COMMUNICATION", value: "38" }
          - { label: "EXTENSIBILITY", value: "170+" }

      - type: quote-block
        variant: "muted"
        align: "center"
        quote: "Every tool is scoped by environment capabilities. allTools vs allSearchableTools — ~30 tools are actively given to the LLM per turn while 600+ are discoverable via ToolSearchEngine. Same SDK at every scale: codebolt.fs.readFile works identically in a CLI script, an IDE agent, a Docker sandbox, or a remote cloud environment."
        attribution: "Tool Registry · Design Notes"

      - type: diagram-section
        heading: "The Engine Stack"
        layers:
          - { label: "Interface Layer — IDE, TUI, CLI, Web", tag: "surface", style: "surface" }
          - { label: "Communication Layer — Agent, Plugin, Client SDKs", tag: "runtime", style: "runtime" }
          - { label: "Coordination Layer — Stigmergy, Deliberation, Pheromones", tag: "coordination", style: "drift" }
          - { label: "Intelligence Layer — Drift Engine, Narrative Versioning (Rust)", tag: "intelligence", style: "versioning" }
          - { label: "Infrastructure Layer — Governance, Environments, Providers", tag: "core", style: "governance" }
        annotation: "Other tools are Layer 1-2. Agent frameworks are Layer 2 only. Codebolt is all five."

      - type: accordion
        heading: "Engine Architecture"
        items:
          - question: "Three Communication Channels"
            answer: "The Agent Channel (codeboltjs) lets external agents connect as child processes with 63+ API modules. The Plugin Channel (plugin SDK) provides WebSocket actions, multiplexed events, and HTTP REST — enabling applications to run inside the engine without separate agent instances. The Client Channel (client SDK) connects UIs with 72 REST modules and 33 WebSocket modules. Agents do work. Plugins connect the engine to the world. Clients give you control."
          - question: "HostBridge: Run Anywhere"
            answer: "The engine never calls platform APIs directly. It defines a HostBridge interface for process spawning, SQLite, Kuzu graph DB, and ONNX inference. Each runtime implements its own bridge: Electron uses UtilityProcess and TypeORM, CLI uses child_process and better-sqlite3, TUI connects via WebSocket proxy. One codebase powers desktop IDE, CLI, headless server, and TUI with identical capabilities."
          - question: "The Provider/Environment System"
            answer: "Providers manage compute environments. The Docker provider creates containers running a dockerserver that connects back to the main instance. Each environment has a full lifecycle (CREATED → RUNNING → STOPPED) with heartbeat monitoring. The Narrative Engine snapshots state per-environment, and git bundles transfer state between them. This enables hierarchical setups where one Codebolt instance orchestrates many others."
          - question: "Agent Lifecycle"
            answer: "Agents are discovered from a marketplace, cached locally, and spawned as child processes. They connect via codeboltjs, call waitForReady(), then handle messages and invoke 63+ API modules. Agents can spawn child agents, participate in swarms, join deliberation councils, create review-merge requests, and manage environments — all through the SDK."
          - question: "Plugin Lifecycle"
            answer: "Plugins are discovered from project .codeboltPlugins/ and global ~/.codebolt/plugins/. Each declares itself in package.json with a codebolt.plugin key. The PluginProcessManager handles lifecycle and trigger-based auto-start. Plugins can do anything agents can, plus subscribe to real-time events and make HTTP API calls. They run inside the engine — no separate instance needed."

      - type: accordion
        heading: "Research Foundations"
        items:
          - question: "Stigmergy-Based Coordination"
            answer: "Agents communicate indirectly through structured shared state instead of direct message passing. Each agent reads from and writes to a shared environment, allowing coordination to emerge without explicit messaging. This is how biological swarms scale to millions — and how Codebolt scales beyond message-passing architectures."
          - question: "Pheromone-Based Task Ownership"
            answer: "Agents deposit pheromones on tasks and files to signal interest and ownership. Configurable pheromone types. Aggregation system for conflict resolution. Lock/unlock mechanisms for exclusive access. This prevents coordination breakdown when agents independently target the same work."
          - question: "The Narrative Engine (Rust)"
            answer: "A Rust-based flight recorder with shadow git for snapshot versioning. Narrative hierarchy: Objective → Thread → Agent Run → Snapshot. Per-thread commit branches. Git bundles for cross-environment transfer. Full execution trace system. Every change carries its narrative — the intent behind it, not just the diff."
          - question: "Drift Tracking"
            answer: "Two-level architecture. Local Rust engine instances assess structural, scope, constraint, and coverage drift within individual agent contexts. The global JavaScript layer aggregates signals across all agents, detecting systemic drift that no single agent would catch."
          - question: "Agent Deliberation Council"
            answer: "Structured deliberations: propose options, respond, vote, reach consensus. Types: decision, review, brainstorm, approval, vote. All stored per-project and fully traceable. Agents make architectural decisions collectively, not by one agent guessing."

      - type: cta-block
        heading: "Convinced by the engineering."
        buttons:
          - { label: "Get Started", href: "/pricing", variant: "primary" }
          - { label: "Read the Docs", href: "https://docs.codebolt.ai", variant: "secondary", external: true }

  # ── Download ───────────────────────────────
  - slug: "download"
    title: "Download Codebolt"
    sections:

      - type: page-header
        title: "Download Codebolt"
        subtitle: "Pick a surface. Same engine inside all of them."

      - type: card-grid
        heading: "Codebolt Editor — Desktop"
        columns: 3
        cards:
          - title: "macOS"
            body: "Apple Silicon and Intel. Universal binary. Requires macOS 12 or later."
            href: "#download-macos"
            visual: |
              codebolt.dmg
              ├─ Apple Silicon
              └─ Intel x64
          - title: "Windows"
            body: "x64 installer. Windows 10 and later. Auto-updates included."
            href: "#download-windows"
            visual: |
              codebolt-setup.exe
              └─ Windows x64
          - title: "Linux"
            body: ".deb, .rpm, and AppImage. x64 and arm64. Includes desktop integration."
            href: "#download-linux"
            visual: |
              codebolt.deb
              codebolt.rpm
              codebolt.AppImage

      - type: feature-block
        heading: "Codebolt CLI — Terminal"
        body: "Install globally with npm and run the engine in your terminal. Headless server mode for CI/CD. Works inside the Editor or standalone — same SDK, same plugins."
        diagram: |
          $ npm i -g codebolt
          $ codebolt                    # interactive TUI
          $ codebolt --prompt "..."     # one-shot
          $ codebolt --server --port 3100
        reverse: false

      - type: feature-block
        heading: "Codebolt Cloud — Browser"
        body: "No install. Open a workspace in your browser, drop in agents and plugins, and run them on managed sandboxes. Same engine as the desktop Editor — just running on our infrastructure."
        diagram: |
          → cloud.codebolt.ai
          ├─ Browser portal
          ├─ Managed sandboxes
          └─ Shared workspaces
        reverse: true

      - type: feature-block
        heading: "Codebolt SDK — Embed"
        body: "Building your own product on top of the engine? The SDK lets you embed the runtime in your app or self-host it on your own infrastructure. Three SDKs (Agent, Plugin, Client) cover every layer."
        diagram: |
          # Self-host the engine
          $ docker run codebolt/engine:latest

          # Or install the SDK package
          $ npm i codeboltjs

      - type: cta-block
        heading: "Need help getting started?"
        buttons:
          - { label: "Read the Docs", href: "https://docs.codebolt.ai", variant: "primary", external: true }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Pricing ────────────────────────────────
  - slug: "pricing"
    title: "Pricing — Codebolt"
    sections:

      - type: page-header
        title: "Pricing"
        subtitle: "Use the engine for free with your own keys. Add managed AI, sandboxes, memory, and team controls when you need them."

      - type: centered-text
        variant: "thesis"
        text: "Codebolt is free to run as an application and cloud workspace in BYOK mode. Paid plans are for managed AI capacity and team infrastructure: model routing across small, fast, text-specialized, coding, embedding, and frontier models; cloud sandboxes; cloud memory; and shared administration."

      - type: pricing-grid
        tabs:
          - label: "Individual"
            cards:
              - tier: "BYOK"
                price: "Always free"
                for: "Bring your own model keys. Use Codebolt's apps and cloud surfaces without paying Codebolt for AI usage."
                features:
                  - "Codebolt Editor, CLI, Cloud, and SDK"
                  - "All core features included"
                  - "Use your own OpenAI, Anthropic, Google, local, or provider keys"
                  - "Run agents, plugins, memory, and workflows"
                  - "Local and self-hosted friendly"
                  - "No Codebolt markup on your own keys"
                cta: { label: "Start Free", href: "/download", variant: "secondary" }
              - tier: "Pro"
                price: "$20"
                price_sub: "/mo"
                for: "Managed AI credits for builders who want batteries included instead of managing provider keys."
                featured: true
                badge: "Early access"
                features:
                  - "Managed AI APIs and embeddings"
                  - "Cloud memory and cloud sandboxes"
                  - "Automatic routing across small, fast, text, coding, embedding, and frontier models"
                  - "Lower effective model cost than using one large model for every task"
                  - "Use BYOK alongside managed Codebolt capacity"
                  - "Plan not active yet; request early access"
                cta: { label: "Request Early Access", href: "#request-access", variant: "primary", waitlist: true, plan: "pro", audience: "individual" }
              - tier: "Max"
                price: "From $100"
                price_sub: "/mo"
                for: "More managed capacity for heavier agent work, larger runs, and more cloud execution."
                badge: "Higher limits"
                options:
                  - label: "Max 5x"
                    price: "$100/mo"
                    description: "More managed AI, embeddings, memory, and sandbox capacity for frequent individual use."
                  - label: "Max 20x"
                    price: "$200/mo"
                    description: "Highest individual capacity for heavier multi-agent runs and longer cloud work."
                features:
                  - "Everything in Pro"
                  - "Higher included managed AI capacity"
                  - "More cloud sandbox and cloud memory usage"
                  - "Better fit for long-running or parallel agent workflows"
                  - "Same multi-model routing strategy to reduce waste"
                  - "Plan not active yet; request early access"
                cta: { label: "Request Early Access", href: "#request-access", variant: "secondary", waitlist: true, plan: "max", audience: "individual" }
          - label: "Team"
            cards:
              - tier: "Team BYOK"
                price: "$10"
                price_sub: "/seat/mo"
                for: "Teams that want shared BYOK administration, collaboration controls, and team-level workspace features."
                featured: true
                badge: "BYOK for teams"
                features:
                  - "Everything in individual BYOK"
                  - "Shared provider keys managed at team level"
                  - "Team workspaces and access controls"
                  - "Shared agents, plugins, and workflows"
                  - "Usage visibility for team-owned keys"
                  - "Designed for teams that already have provider contracts"
                cta: { label: "Request Early Access", href: "#request-access", variant: "primary", waitlist: true, plan: "team-byok", audience: "team" }
              - tier: "Enterprise"
                price: "Custom"
                for: "Organizations deploying Codebolt across teams, infrastructure, compliance boundaries, or private environments."
                features:
                  - "Everything in Team BYOK"
                  - "Custom deployment, self-hosting, and private cloud options"
                  - "SSO / SAML, audit trails, and policy controls"
                  - "Custom guardrails and environment templates"
                  - "Enterprise support and SLA"
                  - "Commercial terms for larger managed AI capacity"
                cta: { label: "Contact Us", href: "mailto:contact@codebolt.ai?subject=Codebolt%20Enterprise", variant: "secondary" }

      - type: accordion
        heading: "FAQ"
        items:
          - question: "How is Codebolt different from Claude Code?"
            answer: "Claude Code is an agent — a great one. You use it. But you can't customize the agentic loop, run multiple agents, or build applications on top of it. Codebolt is the engine that can do what Claude Code does AND scale to multi-agent orchestration, personal agents, and autonomous companies. Start the same way, grow far beyond."
          - question: "How is Codebolt different from Cursor?"
            answer: "Cursor is an IDE with built-in AI agents. Great editor, fixed agents. Codebolt is an engine with a built-in IDE — plus CLI, TUI, and headless modes. You write custom agents, install plugins, and scale to multi-agent. Same quality editor (Monaco), far more flexibility."
          - question: "How is Codebolt different from OpenClaw?"
            answer: "OpenClaw is a personal AI assistant — it manages your inbox, calendar, and daily tasks. Codebolt can do the same thing (run 24/7 with persistent memory and plugins), but the engine also scales to multi-agent orchestration, team coordination, and autonomous companies. OpenClaw is one format. Codebolt is the engine that powers every format."
          - question: "How is Codebolt different from Paperclip?"
            answer: "Paperclip orchestrates agents but doesn't run them — you still need Claude Code, OpenClaw, Cursor, etc. as the actual agents. Codebolt IS the engine. It runs agents AND orchestrates them. One system instead of five tools stitched together."
          - question: "How is Codebolt different from Hermes Agent?"
            answer: "Hermes is a self-improving personal agent by Nous Research — great learning loop and multi-platform messaging. Codebolt can do the same (persistent memory, plugins, always-on), but the engine also scales to multi-agent orchestration and autonomous companies. Hermes is one agent. Codebolt is the engine that can run hundreds."
          - question: "How is Codebolt different from Letta?"
            answer: "Letta is a stateful agent platform — memory-first agents that persist across sessions. Codebolt has the same (3-tier memory, context assembly), plus multi-agent coordination, plugin system, multi-environment scaling, and multiple interface formats (CLI, IDE, TUI, Web). Letta is a great memory system. Codebolt is a complete engine."
          - question: "How is Codebolt different from LangChain or CrewAI?"
            answer: "LangChain and CrewAI are libraries — you import them into your code. Codebolt is a complete engine — IDE, execution environment, coordination system, and infrastructure. Frameworks give you tools to build agents. Codebolt gives them a place to run, coordinate, and scale."
          - question: "I'm using one agent today. Is this for me?"
            answer: "Yes. Start with the CLI and one agent. You get more power than any free coding tool because you control the agent loop, not just the prompt. When you're ready for more, the engine scales with you."
          - question: "Can I run this headless in CI/CD?"
            answer: "Yes. The CLI runs in headless server mode. Spawn environments, run agents, transfer state, monitor progress — all without a GUI."
          - question: "Which AI models does Codebolt support?"
            answer: "All of them. 17+ cloud providers (OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, etc.) plus local models via Ollama and LM Studio. Per-agent and per-task model selection."
          - question: "Why buy managed Codebolt AI instead of using a single model provider directly?"
            answer: "A single provider plan usually pushes most work through a few large models. Codebolt can route different steps to different model types: small models for simple tasks, text-focused models for documentation, embedding models for retrieval, coding models for implementation, and frontier models only when they are actually needed. The headline credit is the spend; the effective useful work can feel lower-cost because the engine avoids using the largest model for every operation."

  # ── Blog ───────────────────────────────────
  - slug: "blog"
    title: "Blog — Codebolt"
    sections:

      - type: page-header
        title: "Blog"
        subtitle: "Engineering decisions, architecture deep-dives, and what we're learning about scaling agents."

      - type: blog-grid
        posts:
          - date: "2026-03-25"
            title: "Why We Built an Engine, Not Another Agent"
            excerpt: "The origin story — why we chose to build a platform engine that can be a CLI, IDE, personal agent, and orchestration system, instead of another single-purpose AI tool."
            tag: "Engineering"
          - date: "2026-03-18"
            title: "CLI to Autonomous Company: The Scaling Spectrum"
            excerpt: "How one engine handles the progression from a single coding agent to orchestrating hundreds of agents across multiple environments."
            tag: "Architecture"
          - date: "2026-03-10"
            title: "How the Plugin System Enables Autonomous Applications"
            excerpt: "Why plugins in Codebolt don't need separate agent instances, how the three communication channels work, and what this means for building autonomous companies."
            tag: "Architecture"
          - date: "2026-03-01"
            title: "Stigmergy vs Message Passing for Agent Coordination"
            excerpt: "A research-backed comparison of coordination strategies. Why indirect communication through shared state scales better than direct messaging."
            tag: "Research"
          - date: "2026-02-20"
            title: "What Breaks When You Run 50 Agents on One Repo"
            excerpt: "Real problems we encountered scaling agent coordination — conflicts, drift, memory exhaustion — and the system-level solutions we built."
            tag: "Engineering"
          - date: "2026-02-10"
            title: "Agent Deliberation: How Agents Make Decisions Together"
            excerpt: "Inside the deliberation council system — proposing, debating, voting, and reaching consensus without human intervention."
            tag: "Architecture"

  # ── About ──────────────────────────────────
  - slug: "about"
    title: "About — Codebolt"
    sections:

      - type: centered-text
        variant: "thesis"
        text: "We saw the gap between what AI agents promise and what they can actually deliver. The bottleneck isn't intelligence — it's the engine. We built the engine."

      - type: two-column-text
        columns:
          - heading: "What everyone is building"
            body: "Smarter models. Better prompts. Faster autocomplete. Personal assistants for your inbox. Copilots that finish your sentences. Each tool does one thing."
          - heading: "What's actually missing"
            body: "An engine that can be any of those things — and scale beyond all of them. A single system where your agents, plugins, memory, and workflows carry across every format and every scale."
        conclusion: "Codebolt is that engine."

      - type: value-list
        heading: "What We Believe"
        values:
          - "The engine is the multiplier, not the model."
          - "Agents are programs, not prompts. Give developers the SDK."
          - "One engine should handle every scale — CLI to autonomous company."
          - "Everything you build should carry forward as you grow."
          - "Depth over breadth. Solve the hard coordination problem well."
          - "Honesty over hype. Show the architecture, not the adjectives."

      - type: centered-text
        heading: "The Engineering"
        text: "Codebolt is built from scratch — not forked, not wrapped. 73 controllers, 134 services, a Rust-based Narrative Engine, three communication channels, and a HostBridge abstraction that runs identically on desktop, CLI, and headless server. Every layer exists because the problem demanded it."

      - type: cta-block
        heading: "We're building the engine for the agent era."
        buttons:
          - { label: "See Open Roles", href: "/careers", variant: "primary" }
          - { label: "Explore the Engine", href: "/engine", variant: "secondary" }

  # ── Careers ────────────────────────────────
  - slug: "careers"
    title: "Careers — Codebolt"
    sections:

      - type: page-header
        title: "Build with us."
        subtitle: "We're building the most powerful agent engine ever made. If that excites you, we should talk."

      - type: centered-text
        text: "Engineering-first culture. Small team. Hard problems. Real impact on how autonomous development works. We care about depth, craftsmanship, and building things that hold up under pressure. Remote-friendly."

      - type: role-list
        heading: "Open Roles"
        roles: []
        empty_message: 'No open roles right now. But if you think you should be here, email <a href="mailto:eng@codebolt.ai">eng@codebolt.ai</a>.'

  # ── Changelog ──────────────────────────────
  - slug: "changelog"
    title: "Changelog — Codebolt"
    sections:

      - type: page-header
        title: "Changelog"
        subtitle: "What shipped, when."

      - type: timeline
        entries:
          - date: "2026-03-15"
            version: "v1.0.0"
            summary: "Codebolt Engine v1. Full CLI, IDE, and headless modes. 63+ SDK modules. Plugin system with 3 communication channels. Multi-environment provider system."
          - date: "2026-02-15"
            version: "v0.9.0"
            summary: "Provider system for multi-environment scaling. Codebolt instances coordinate with each other via git bundle state transfer and heartbeat monitoring."
          - date: "2026-02-01"
            version: "v0.8.0"
            summary: "Plugin SDK with three communication channels. Build applications that run inside the engine without separate agent instances."
          - date: "2026-01-18"
            version: "v0.7.0"
            summary: "Agent deliberation councils — propose, debate, vote, consensus. Automatic review-merge system with pheromone-based coordination."
          - date: "2026-01-05"
            version: "v0.6.0"
            summary: "Drift engine v2 — two-level architecture with local Rust assessment and global JavaScript coordination."
          - date: "2025-12-20"
            version: "v0.5.0"
            summary: "Stigmergy-based coordination replaces message-passing. Pheromone task ownership. Significant scaling improvements."
          - date: "2025-12-01"
            version: "v0.4.0"
            summary: "Narrative Engine (Rust) with shadow git snapshots. Agent attribution. Execution trace graph with replay."
          - date: "2025-11-15"
            version: "v0.3.0"
            summary: "HostBridge abstraction. One engine now powers desktop IDE, CLI, and headless server with identical capabilities."