Skip to content
agent-connector

Agent Architecture

Crush

Crush is a Charm terminal coding agent with multi-model support, session-based workflows, LSP context, MCP over stdio/http/sse, cross-platform terminal support, project/global JSON config, environment expansion, and built-in configuration skills.

Source reviewed #28Checked 2026-07-06
Setup guideSource
Run type
CLI
Adapter
json-stdio
Source
OSS · charmbracelet/crush
Stars
★ 28k

Archive Context

This page is one host entry inside the full architecture archive and keeps multi-surface products visible instead of collapsing them into a single run type.

42 host archive
Host page
crush
Run cohort
CLI: 30
Archive route
/agents

Host Surface Perspectives

The host is the primary architecture boundary. Each runnable surface below separates what the host owns from what agent-connector can safely install for Crush.

1 surface entry

CLI

cli
Host entry
A terminal command owns the process, current working directory, stdin/stdout, shell environment, and project file discovery.
Host owns
The CLI host owns agent loop timing, approval prompts, tool execution, session files, and how hook or MCP subprocesses are launched.
Connector role
agent-connector can only write the host's documented CLI config, prompt, memory, hook, MCP, or package files and point them at the home binary. Current wired connector surfaces: MCP server, Hooks, Skills, Memory.
Implementation consequence
A CLI surface is byte-addressable and smoke-testable from a temporary HOME, but terminal UI behavior still belongs to the host process. No visible host-native gap is currently tracked for this surface.

Verified Architecture

Source-checked on 2026-07-06. These notes are intentionally separate from the generated surface matrix below.

Sequence #28

Source pass

Current source review findings are kept as the first architecture section so readers can separate external evidence from the generated local coverage model.

  • Crush is a terminal coding agent with multi-model support, session context, LSP-assisted context, and MCP extensibility.
  • Configuration is resolved from project and user JSON files, and ephemeral state is stored separately under user data directories.
  • Crush MCP supports stdio, HTTP, and SSE transports with shell-style expansion, which is a host-specific config behavior the archive should note.

Runtime boundary

The adapter target is the Crush terminal runtime. Crush owns the TUI, session state, LSP context, provider/model switching, package installs, cross-platform behavior, and Charm ecosystem integration.

  • Crush supports macOS, Linux, Windows PowerShell/WSL, Android, FreeBSD, OpenBSD, and NetBSD.
  • It can switch LLMs mid-session while preserving context.

MCP registration

Crush has explicit MCP support over `stdio`, `http`, and `sse`, with shell-style value expansion in command, args, env, headers, and URL. That makes its MCP surface stronger than many source-light hosts.

  • Config priority is `.crush.json`, `crush.json`, then `$HOME/.config/crush/crush.json`.
  • Unset variables and required variable syntax are handled by Crush's embedded shell expansion.

Hook bridge

agent-connector tracks Crush as a json-stdio hook host. Public source also shows a `docs/hooks` folder, so hook claims should be expanded from source review rather than generic terminal behavior.

  • Hook docs in the repository make this a good candidate for deeper event-level analysis.
  • LSP and MCP should remain separate from lifecycle hooks.

Content surfaces

Crush content surfaces include project/global config, LSP definitions, provider settings, context paths, TUI options, AGENTS.md, `.agents/skills`, and built-in `crush-config` skill behavior.

  • The repository includes `.agents/skills`, `AGENTS.md`, `crush.json`, and schema files.
  • LSP context makes editor-like code intelligence available from the terminal.

Marketplace and host-only affordances

The host-only affordance is a polished Charm terminal stack: portable TUI, broad package-manager installs, LSP-aware context, MCP transport variety, and a strong open-source repository.

  • Charm ecosystem packaging should be visible as a support surface.
  • Crush is a good reference for terminal-first but IDE-like context design.

Host-specific shape

Crush is a json-stdio CLI host with MCP, hooks, skills, and memory; commands, subagents, statusline, and actions are intentionally left absent.

  • Form factor: CLI.
  • Native surfaces: MCP server, Hooks, Skills, Memory.
  • Wired surfaces: MCP server, Hooks, Skills, Memory.
  • Visible gaps: none.

Hooks

Hooks enter through a host-launched command that exchanges event JSON over stdio.

MCP

The adapter writes this host's native MCP registration dialect, including its root key, scope, transport fields, and environment syntax.

Memory

Managed memory text is written into the rules or memory file this host actually reads, with ownership markers for reversible uninstall.

Marketplace and affordances

Current install is a direct native-file write path; any package artifact is manual unless a driver is added.

  • Runtime handlers: none.
  • User-visible affordances: Users see managed skills + memory surfaces after install; runtime-only surfaces stay behind the host boundary..

Known Limits

  • Hook event details should be sourced from Crush's hook docs before adapter expansion.
  • MCP support is strong but does not replace separate hook verification.
  • Provider model lists may change quickly.

Evidence checked

Crush repositoryCrush website

Architecture Diagram

Host-specific flow for the CLI surface.

json-stdio
Host-owned architecture flowHost surfaceCLIRuntimejson-stdioNative artifactsMCP + hooks + content + memoryConnector boundarystdio eventsUser surfaceskills + memoryagent-connector writes only documented host artifacts; the host owns the agent loop.
  1. 1
    Entry point: CLI

    Terminal agent process reads user/project config and invokes the connector home binary for runtime callbacks.

  2. 2
    Connector package

    defineConnector package declares server, hooks, content, memory, and actions.

  3. 3
    Adapter module: crush

    json-stdio renderer at src/adapters/crush/index.ts.

  4. 4
    Native host artifacts

    Adapter writes MCP config + hook config + content files + memory/rules through this host's native file, package, or marketplace surface.

  5. 5
    Runtime boundary

    host launches JSON-stdio hook command

  6. 6
    User-visible surface

    Users see managed skills + memory surfaces after install; runtime-only surfaces stay behind the host boundary.

  7. 7
    Coverage ceiling

    4/4 native surfaces wired. No visible host-native gap in the current coverage matrix.

Component Diagram

Static parts of the Crush integration and which side owns each one.

Components and ownershipCrush hosthostagent-connector packageconnectorcrush adapterjson-stdioNative artifactsartifactsRuntime bridgeruntimeUser-visible surfaceuser
  • Crush host

    CLI surface owns the model loop, UI shell, config discovery, and native lifecycle for this integration.

  • agent-connector package

    Normalizes connector declarations into MCP, hook, memory, content, and action payloads before delegating to a host adapter.

  • crush adapter

    Implements the json-stdio translation layer in src/adapters/crush/index.ts.

  • Native artifacts

    Adapter writes MCP config + hook config + content files + memory/rules through this host's native file, package, or marketplace surface.

  • Runtime bridge

    host launches JSON-stdio hook command

  • User-visible surface

    Users see managed skills + memory surfaces after install; runtime-only surfaces stay behind the host boundary.

Runtime Sequence Flow

Message order from install to runtime for the CLI surface.

User / projectagent-connectorcrush adapterCrushAgent runtimeCoverage matrix1. Choose host adapter2. Resolve connector declaration3. Render host-native shape4. Host loads artifacts5. Run through host boundary6. Expose remaining ceiling
  1. 1 · User / project
    Choose host adapter

    Install or update starts against Crush; the selected surface is CLI.

  2. 2 · agent-connector
    Resolve connector declaration

    The package reads connector metadata and routes it to the crush adapter instead of exposing a generic host contract.

  3. 3 · crush adapter
    Render host-native shape

    Adapter writes MCP config + hook config + content files + memory/rules through this host's native file, package, or marketplace surface.

  4. 4 · Crush
    Host loads artifacts

    host launches JSON-stdio hook command

  5. 5 · Agent runtime
    Run through host boundary

    Users see managed skills + memory surfaces after install; runtime-only surfaces stay behind the host boundary.

  6. 6 · Coverage matrix
    Expose remaining ceiling

    4/4 native surfaces wired. No visible host-native gap in the current coverage matrix.

Architecture Archive

The same five study axes are rendered for every host: runtime shape, hooks, MCP, memory, and host-only affordances.

Host-specific shape

Crush is a json-stdio CLI host with MCP, hooks, skills, and memory; commands, subagents, statusline, and actions are intentionally left absent.

  • Form factor: CLI.
  • Native surfaces: MCP server, Hooks, Skills, Memory.
  • Wired surfaces: MCP server, Hooks, Skills, Memory.
  • Visible gaps: none.

Hooks

Hooks enter through a host-launched command that exchanges event JSON over stdio.

MCP

The adapter writes this host's native MCP registration dialect, including its root key, scope, transport fields, and environment syntax.

Memory

Managed memory text is written into the rules or memory file this host actually reads, with ownership markers for reversible uninstall.

Marketplace and affordances

Current install is a direct native-file write path; any package artifact is manual unless a driver is added.

  • Runtime handlers: none.
  • User-visible affordances: Users see managed skills + memory surfaces after install; runtime-only surfaces stay behind the host boundary..

Special Feature Inventory

Host-specific capabilities separated from the generic surface matrix: lifecycle hooks, MCP registration, memory/rules, marketplace delivery, and UI or content affordances owned by the host.

Lifecycle hooks

Wired

Hooks enter through a host-launched command that exchanges event JSON over stdio.

MCP registration

Wired

The adapter writes this host's native MCP registration dialect, including its root key, scope, transport fields, and environment syntax.

Memory and rules

Wired

Managed memory text is written into the rules or memory file this host actually reads, with ownership markers for reversible uninstall.

Marketplace delivery

Direct files

Current install is a direct native-file write path; any package artifact is manual unless a driver is added.

Host-only affordances

1/1 wired

Wired host affordances: Skills. Host-native gaps: none. Not confirmed: Commands, Subagents, Statusline handler, Action affordances.

Source Review Notes

Latest source pass for host-specific architecture details. This is separate from generated adapter coverage and local drift guards.

Checked 2026-07-06Open review source
charmbracelet/crush repository
  • Crush is a terminal coding agent with multi-model support, session context, LSP-assisted context, and MCP extensibility.
  • Configuration is resolved from project and user JSON files, and ephemeral state is stored separately under user data directories.
  • Crush MCP supports stdio, HTTP, and SSE transports with shell-style expansion, which is a host-specific config behavior the archive should note.

Evidence Map

Each host page ties public source evidence to the local adapter and drift guards that keep the rendered archive aligned with code.

Public source: charmbracelet/crush

Primary public repository or product source used for current host status and source links.

external
Open source

Local adapter implementation

Defines the install/uninstall behavior, native config rendering, capability flags, and any runtime parse/format bridge for this host.

local
src/adapters/crush/index.ts

Platform metadata and host-native matrix

Records the form factor, public source target, ranking source, native host surfaces, and current agent-connector coverage cells.

local
site/src/platform-data.ts

Architecture drift guard

Asserts that every registered host has a page, diagram, host-specific brief, source link, form-factor band, and adapter-aligned surface data.

local
tests/docs/platform-drift.test.ts

Runtime Shape

Hooks are dispatched through a host-launched command. The adapter parses host JSON, calls the connector handler, and formats the reply back to the host contract.

MCP registration
Wired through this adapter
Hook bridge
Wired

Connector Surfaces

Static content

MCP server, Hooks, Skills, Memory

Runtime handlers

No runtime handler surfaces wired

Surface Matrix

Wired means agent-connector installs it now. Host native marks support we know about but have not wired yet.

SurfaceStatus
MCP server
Static content
agent-connector installs this surface today.
Wired
Hooks
Static content
agent-connector installs this surface today.
Wired
Commands
Static content
No confirmed host-native surface.
N/A
Skills
Static content
agent-connector installs this surface today.
Wired
Subagents
Static content
No confirmed host-native surface.
N/A
Memory
Static content
agent-connector installs this surface today.
Wired
Statusline handler
Runtime handler
No confirmed host-native surface.
N/A
Action affordances
Runtime handler
No confirmed host-native surface.
N/A