Comparison matrix

by David P. S. Marques

Ten dimensions across twelve open-source harnesses, every cell pinned to the evidence endnotes in that harness's article. Superscript numbers link to the claim's source. Scroll horizontally to compare.

#Dimensionpi (v1.0.2)aider (v0.86.2)Cline (v4.1.22)Goose (v1.53.0)Codex CLI (rust-v0.160.0)OpenHands (v1.53.0)OpenCode (v1.18.34)Hermes (v2026.9.24)OpenClaw (v2026.9.9)Gemini CLI (v0.63.0)SWE-agent (v1.1.0)Qwen Code (v0.25.0)DGM (a565fd2)Autohand Code CLI (v0.9.8)DeepSeek Harness (dsh-v0.2.1-alpha.3)Deep Agents (v0.7.25)Grok Build (2bdd1d6)Harness² (1cfe254)Agensh (v1.0)dsh-superagent (v0.1.0 @ 6337fc8)ZCode (3.16.2 @ 3c5b227)Everruns (v0.49.0 @ 4e8002a)MIKE (v0.1.0 @ 382ec61)
1Agent loopEvent-sourced; inner (tool/steer) + outer (follow-up) loops; no iteration cap 5, 6, 10No tool-call loop; parse→apply→reflect over text edit formats; REPL + reflection (≤3) + retry; no REPL iteration cap 4, 6, 8Host-independent SDK AgentRuntime.execute; turn loop + tool execution; maxIterations: undefined in VS Code host — bound is 5 identical tool calls 7, 13, 14Two loops, migration in progress: legacy agent.rs plain loop{} (default, max_turns=1000) vs opt-in effect-sourced state machine (GOOSE_STATE_MACHINE=1); LLM call dead last 3, 6, 7, 10Three nested: RegularTask::run → run_turn loop{} (one sampling request/iter) → stream-consumer + retry; condition-driven; no max_turns anywhere in 154 crates — bound is retry budget + compaction-once-per-step + user interrupt 5, 7, 9Event-sourced; LocalConversation._run → Agent.step → pure classify_response; max_iteration_per_run 500; stop hooks can veto FINISHED 18, 19, 20, 26runLoop while(true) in session/prompt.ts; exit = finish reason ≠ tool-calls + no pending tool calls + parentID == user message; maxSteps defaults Infinity (injects wrap-up prompt, never kills); prompt() serializes concurrent prompts via state.ensureRunning 5, 6, 7, 8Synchronous one-turn run_conversation (turn loop lives in gateway/CLI drivers); in-turn loop, max_iterations 500 (subagents 250); per-phase sibling modules (preflight, assembly, tool round, overflow, compaction, stop gates, finalizer); session turn lease serializes concurrent prompts 5, 6, 7, 28Four nested layers: runLoop() raw model→tool loop (executes tool calls as they stream in via streamAgentResponse, steering-queue injection) → Agent class (transcript ownership) → AgentSession mixin chain → gateway execution; no hard max-turn counter — delegated to prepareNextTurn/shouldStopAfterTurn hooks; tool-loop recovery detector 7, 9, 10, 11, 12sendMessageStream → processTurn → Turn.run; MAX_TURNS=100; per-turn composite model router (fallback → ... → default); loop detector + next-speaker LLM check; loop split: core streams/decides, CLI schedules/feeds back 6, 8, 12, 13Sync while not done - one model call → one command per step, .traj rewritten every step; termination = submit/exit/forfeit/error-autosubmit/cost/context/timeout; no step cap; optional RetryAgent outer attempt loop 9, 10, 11, 12Recursive sendMessageStream re-entry (no processTurn); MAX_TURNS=100 + session-turn cap + session-token-limit gate; 8 SendMessageTypes; next-speaker check skipped by default; Stop/MessageDisplay hook stages 8, 10, 13, 18Outer: fixed evolution driver — 80 gens × 2 children, ThreadPoolExecutor, 1.5h per-child timeout, compile filter, JSONL checkpoint. Inner: single-shot forward() → native tool loop, no step cap, bare-except termination 2, 3, 10, 11Bounded for loop (runAgentReactLoop); cap 100 iterations (1,000 executing a plan), exhaustion ending in a summary call rather than a kill; model-declared finish; loop/reflection repair guards ride along; steering queue (≤32 messages) drains only at iteration boundaries 10, 11, 13, 16The loop itself is a bundle plugin row (ReactLoopAgent); kick() runs turns that re-derive context from the append-only session log at each step; no built-in turn budget — a run ends when the model stops calling tools, on abort, or via an agent/turn-stopping hook veto; an advisory repeat-tool reminder fires at 3/5/8 identical calls 1, 12, 14, 15No loop in this repo — create_deep_agent() assembles a middleware stack into LangChain's create_agent graph, whose routing edge exits when the model stops calling tools; LangGraph Pregel executes it in super-steps, checkpointing after every step; the only budget is recursion_limit: 9_999, enforced as GraphRecursionError only when no stop condition is reached 1, 51, 53, 54Explicit loop {} in the shell session actor; one sampler round-trip per iteration; a turn ends on a response with no tool calls; no default turn cap (max_turns is an optional per-agent-definition field, default None); a stationarity guard nudges at 8 identical steps (4 for reads/plan) and hard-stops at 12 (8); two-pass compaction prefires at 85% of the window 4, 7, 8, 10No turn loop in-package — a budgeted search over harness trees: k shared base rollouts → 2k dimension-split proposals (INV procedure / DOM practitioner knowledge) → k compositions; parallel mode (independent draws and compositions) or sequential mode (checkpointed rounds c1..ck, all checkpoints are finals); the ledger asserts R = 4k rollouts / P = 3k sessions per task-mode 3, 9, 11Two nested loops: Copilot CLI turns over ACP inside a prompt-carried cooperation loop (observe, CLAIM, build, verify, push/PR/self-merge, PATCH_SUMMARY, repeat); no scheduler or assignment in code; wall-clock termination bent by runner deadline posts and an idle watchdog 2, 10, 49Borrowed turn loop (dsh Sessions, #15); the native loop is operational: poll -> Trigger -> Eval -> Ticket/Assignment, pumped by 2 s passes (evaluateDue) 18, 19, 20Unbounded turn loop fed by one runtime command queue (prompts, steering, background/workflow results, goal continuations); per iteration: drain queue, micro/auto-compact (rapid-refill circuit breaker), MCP refresh, reminder assembly, one model step; a session Goal layer continues the loop across turns when idle 3, 4, 18Reason–act cycle over a journaled log: a worker leases the session (durable actor model) and runs the whole turn with no queue hop between steps; 500-iteration default cap; sans-IO pure planner core 1, 21, 32Per-task executor loop in the server: stream one completion, persist the turn, run its tool calls, repeat; no iteration cap — bounds are a consecutive-failed-turn limit (per-task, default 3), loop detection, an optional loop breaker 9, 13
2Tool system8 built-ins (4 active by default) + registry; TypeBox validation; sequential/parallel; nested calls 22, 27, 28None — model emits SEARCH/REPLACE blocks parsed by edit-format coders; shell suggestions run only with per-block confirmation 14, 189 built-ins (7 active in VS Code act mode) + MCP natives + team tools (SDK/CLI); sequential default, adjacent-parallel batching; 30s default timeout 12, 28, 29Entirely MCP-shaped: every tool is an MCP server (builtins = in-process tokio duplex); ext__tool namespacing; no non-MCP path 2, 21, 23Responses API function tools; ToolRegistry (IndexMap) + ToolExecutor trait; ToolExposure (Deferred + tool_search); concurrent dispatch (FuturesOrdered); no built-in read_file/write_file/edit — reads via exec_command, edits via apply_patch 10, 23, 24, 25Spec/registry split; SDK never imports openhands-tools; Pydantic validation; parallel batches in original order 8, 47, 54ToolRegistry.tools() rebuilds per request for the exact model; usePatch swaps apply_patch for edit+write on GPT-family; tool.definition plugin hook rewrites definitions; MCP + plugin tools join dynamically; websearch gated to opencode provider 9, 10, 11Import-time self-registration (schemas validated at registration); single handle_function_call funnel (bridge unwrap → middleware → plugin hooks → ACP approval → execute); Tool Search bridge collapses 100+ tools to tool_search/tool_describe/tool_call; MCP discovery deliberately deferred out of import (once blocked the gateway 120s) 14, 15, 16, 17AnyAgentTool registry + runtime factories; effective surface merges six sources (core, shell, channel, OpenClaw, plugin, Tool Search) then sandbox/profile/provider/sender/group/sub-agent policy filters; Tool Search materializes on demand — most tools never enter model context 29, 3026 built-ins; ToolRegistry.sortTools() priority order (built-in → project → MCP); no tool search - every active tool serialized into getFunctionDeclarations() each turn; wait_for_previous injected; model-family declaration overrides 24, 25, 26, 27The ACI: YAML-declared commands → OpenAI function schemas / shell strings; container-side script implementations; 9 text parsers; blocklist-only permissions, zero approvals 3, 6, 8, 20~54 built-in tool classes (+ goal/omni/workflow tools, ~60-70 potential); lazy mode-gated registration; ToolSearchTool + shouldDefer schema hiding - only a curated core set rides each request 31, 32, 33, 34Exactly two tools (bash, editor); tool_info() + tool_function() contract; bash's "persistent state"/"no internet" claims false in code; editor overwrites whole files; 10k truncation 18131 default tools in a hand-rolled schema subset, relevance-filtered per iteration by keyword/category heuristics; MCP servers namespaced into the registry with flattened schemas; agent-authored meta-tools via create_meta_tool behind a handler blocklist 18, 19, 21, 22Effect-registered, per-agent-scope registry; every call traverses tools/pre-execute waterfall listeners (veto or ask) and tools/post-execute listeners; no tool search — native mode sends every mounted schema; the PTC presentation collapses the wire surface to a single run_code tool whose sub-calls re-enter the full guarded pipeline; MCP is client-only 19, 21, 38Middleware-provided: fs tools (ls / read_file / write_file / edit_file / delete / glob / grep) + execute (execution-capable backends only, filtered per request by backend capability) + the task delegation tool; caller tools pass through verbatim; no tool search — visibility via construction allowlists and profile excluded_tools; MCP arrives via external adapters as ordinary tools 21, 15, 16, 23Registry-declared tools in three toolsets (native, concise, hashline) plus in-tree Codex and OpenCode ports; per-agent allowlist/denylist filtering backed by a vendor-name compatibility mapping between tool naming schemes 16, 17None of its own — the substrate's tools, reached through a pinned OpenCode checkout run from source via bun or a versioned Codex dist; the package's own tool surface is the file-editing workspace granted to proposer sessions 60, 43Copilot's native tools + git CLI + curl, plus three stdio MCP servers (Gitea, Mattermost, board) wrapped by the notice shim; a 60-entry MCP deny list fences repo/file/channel administration; Copilot's own subagent tools are excluded — the team is the subagent mechanism 39, 40, 46Router Session: Engine commands only under a read-only preset (no file writes, subagents or web); workers: six orchestration verbs plus dsh's full tool set 11, 13, 62~45 built-ins (Bash with a deep command-analysis family, file/web/todo/plan tools, subagents + coordinator messaging, a dynamic-workflow authoring family, Cron/OffPeak scheduling, a js repl, Skill, ToolSearch, GoalRead) + MCP servers initialized/refreshed in-loop; every tool entry carries schema, result budget, timeout, trace policy and a permission spec 10, 6Capability-provided tools (~60 documented capabilities); every tool declares MCP-style hints plus a SideEffectClass (Pure/Idempotent/AtMostOnce) driving approvals and crash reruns; MCP catalogs paged in full, searched, revealed within 32 tools / 64 KiB defaults 12, 4513 core tools (files, bash, board, LSP) behind one dispatch table; plan mode swaps in a read-only bash; MCP per project opt-in; extension tools are data-declared HTTP calls 24, 46
3Model providers~42 behind one StreamFn; per-request key resolution 18, 29litellm behind a Model wrapper; 313-entry YAML + substring heuristics (model-aware, load-bearing); weak model for commits/summaries 25, 26228 providers, one generic Vercel AI SDK adapter; exact-ID resolution; data-driven per-model behavior; ~200k-line generated catalog 6, 23Single Provider trait (stream() required); 36 static + 48 declarative JSON + custom; 8,160-entry models.dev snapshot (zstd-bundled, ETag hot-swap) + substring heuristics; no name validation 34, 35, 36Responses-API-only (WireApi single variant; "chat" rejected); 5 built-in providers (openai, 2× Bedrock, ollama, lmstudio); 8 auth modes; ModelProvider trait; WS-first + HTTP/SSE fallback to /responses; retries 5 (cap 100) 3, 31LiteLLM; Chat Completions + Responses API; per-completion RouterLLM; agent self-swaps via switch_llm 40, 55, 84, 86Live ModelsDev catalog (fetched, cached with locking, refreshed) — never ships stale; dual runtime: Vercel AI SDK default (streamText) + opt-in native @opencode-ai/llm behind OPENCODE_EXPERIMENTAL_NATIVE_LLM; both converge on one LLMEvent stream 12, 13, 14, 15~40 providers as lazily-discovered plugins; ProviderProfile with chat_completions / codex_responses API modes; reasoning rides assistant_msg["reasoning"] 24llm-core transport-adapter contract (stream/streamSimple → normalized async-iterable); packages/ai registry maps API IDs to providers; per-vendor extensions declare auth, catalogs, thinking policies; modelFallback is last-resort chain resolution, never runtime failover 33, 34Gemini API; per-turn composite router (fallback → override → approval-mode → classifiers → default); routing auditable via ModelRoutingEvent telemetry; sequence-model stickiness across turns 8, 19, 42LiteLLM - any provider by model-name string; per-instance ($3.00) / total cost + call limits; API keys as SecretStr with $ENV/::: rotation; special human, replay, instant_empty_submit models 136-auth-wire dispatch; 13-preset registry + setup wizard; no per-turn router - explicit /model selection resolved per call; models.dev bundled/live catalog; Qwen PKCE OAuth primary 49, 50, 55, 52Inner agent = Bedrock Claude 3.5 Sonnet (o3-mini for polyglot); diagnoser = o1-2024-12-17; ~20 models listed, narrow wiring; MAX_OUTPUT_TOKENS = 4096, temp 0.7 1217 providers behind one LLMProvider interface; the factory defaults to OpenRouter with an unconfigured-provider fallback; a capability flag (supportsNativeToolCalling) switches between native tool calls and a text emission protocol — much of the loop's repair machinery exists to police the text path 44, 20All model traffic goes through one seam, ctx.llm, with provider adapters behind it — the official DeepSeek API or BYOK providers; provider-scoping is visible in code (the session-log upload field is added only by the official adapter, never for BYOK) 12, 30Any LangChain chat model via init_chat_model (provider:model strings); per-model harness profiles (Anthropic, OpenAI Codex, NVIDIA built in) and provider profiles shape the resolved kwargs; public registration APIs exist for both profile kinds 4, 41First-party two ways: session/OAuth traffic via cli-chat-proxy.grok.com/v1, API-key inference via api.x.ai/v1; three wire backends (chat completions, messages, responses) selected per catalog entry; BYOK custom models carry their own base URL, key, extra headers, and a required context-window field 12, 13, 11, 14Solver / improver / selector / judge as separate env-configured channels over two transports — an OpenCode channel (provider-prefixed model ids) or a Claude CLI channel (Vertex auth); the improver defaults to the solver model 31, 36The borrowed harness's provider: Copilot only in this release (any other AGENT_KIND is fatal), Copilot pinned at 1.0.70, gateway-configured model (defaults gpt-5.6-sol, high effort, 272k window) 14, 6None of its own: models are whatever the dsh host provides (#15); the bundle's only model-facing choices are its two presets, router and worker 2A real registry: the bundled built-in config (revision 33) defines 21 provider templates over three API shapes (anthropic-messages, openai-chat-completions, openai-responses), GLM-first (Z.ai/BigModel, GLM-5.3) ahead of Kimi, MiniMax, DeepSeek, Qwen, MiMo, OpenAI, Anthropic, xAI, OpenRouter, OpenCode Go/Zen; built-in configs are revision-checked releases (bundled / last-known-good / remote-synced); official coding-plan gateway rewrites plan endpoints 27, 28, 30Provider-neutral driver layer: OpenAI, Anthropic, Gemini, Bedrock, Azure OpenAI, Mistral, Fireworks, Cloudflare, Meta, MAI and others; switching provider does not change the agent definition; hosted tools/search negotiated per driver 14Named OpenAI-compatible endpoints (llama.cpp home case) behind one streaming client; per-provider concurrency slots; agent extensions join as agent:// providers; llm extensions reshape requests 35, 54
4Prompt constructionStructured sections, diffed per turn, XML-tagged 15, 16Fixed wire order with synthetic user/assistant pairs; prompt-cache breakpoints on stable prefixes; repo map re-injected per turn 10, 11Template + placeholder replacement; MessageBuilder normalization; rules as # Rules sections 21PromptManager from extension info + directory hints + goose mode; toolshim/native split per model; moim agent-only turn-context message 14Prompt → ResponsesApiRequest (store: false, stream: true, thread prompt_cache_key); responses-lite shape (UUIDv5 prefix-cache IDs); assembly base→developer→user; fragments hard-capped (AGENTS.md ≤10K) 14, 32Cached incremental view with enforced invariants; progressive disclosure 37, 38, 15System prompt assembled per turn (environment, instructions, MCP servers, skills); SessionProcessor.create() pre-captures the working tree before the model call; handle.process() calls LLM.Service 25, 26, 27Byte-stable system prompt for the conversation's life (prefix-cache invariant); skill invocations ride user messages, never the system prompt; tool schemas memoized per registry generation 8Context-engine assembly per turn (history from per-agent SQLite, replay validated, context-window limited); skills delivered through the prompt system (skillsSnapshot, instruction-delivery caches); session-bound 26, 40System prompt + tiered GEMINI.md injection (global → extension/project → per-directory JIT); per-turn model-dependent tool refresh; BeforeModel hooks can rewrite the request 46, 19, 20Jinja2 system/instance/next-step templates + auto-generated command_docs; 100k observation cap with elision note; history processors (identity/trim/cache-control); no summarization - elide/trim/tag only 14, 156-layer system prompt (autoMemory last, cache-prefix aware); frozen at startChat, refreshed on events; Anthropic two-block cache_control split; prelude re-prepended after compaction 57, 58, 59, 60Diagnoser prompt = full inner-agent source + failure evidence + private test patch → JSON contract; rewrite prompt = summary + suggestion + problem description; guardrails are prompt text 13, 14, 15System prompt rebuilt per request by SystemPromptBuilder, including a ## User Preferences & Memory block recalled from the event-sourced store plus an extractive summary tree; skills resolved across 11 sources with later-sources-win precedence 33, 8Context is derived per step from the session log under a stated invariant (model-visible ⟺ logged); skill summaries are advertised in the prompt with bodies fetched on invocation; threshold compaction emits a keeping the newest 16% of the window verbatim 5, 37, 17Caller prompt + harness-profile suffix (the authored base prompt is deprecated); middleware appends fragments per request — the subagent roster inside the task tool description, skills metadata under progressive disclosure, memory files under ; LangChain prompt-caching middleware preserves the prefix 16, 42, 39, 7Per-turn assembly from the agent definition, project instructions, and filtered tool schemas; at the compaction threshold, summaries replace history — the threshold itself resolves through the remote-settings tiers to a hardcoded 85% default, and the remote payload can also carry a server-decided consent-gate notice 10, 3Evidence-as-files plus a short mission pointer; trajectories full and untruncated (per-observation clip 50k default, 10k floor enforced in code); per-dimension job templates interpolated with BenchPrompts values that may not mention grading 16, 24, 29One rendered file (agents.txt + brief, to /work/AGENTS.md) carries identity, substrates, board discipline, event semantics and the work cycle; per turn the dispatcher prepends a board snapshot as a single-use ACP prompt prefix; urgent notices are appended to tool results mid-turn 13, 16, 19A shipped prompt set is the behaviour layer: orchestrator.md (16 lines), the admission.md rubric, dispatch.md, worker/work prompts and prompts/team/* norms; candidate cards rendered by the app 12, 36, 60Per-turn assembly in the loop: system sections + injected reminders (collaboration mode, todo, goal state as an authoritative block with the objective wrapped as untrusted data, prefetched memory recall, plan mode); continuation turns get a generated prompt with budget accounting and a completion-audit checklist; verifier turns get a dedicated no-tools, JSON-only prompt 9, 14, 13Folded from the session log each reason step: system prompt + journaled history (messages are a projection of events) + schemas as disclosed by tool search; compaction checkpoints shrink the prompt, never the log; execution phases annotated 5, 28Rebuilt per run from SQLite rows: base template with tool list, skills at container paths, latest summary, project AGENTS.md in <instructions>, mode templates, date, working directory 22, 23
5Memory/sessionJSONL sessions; compaction with branch summarization 30In-memory cur/done messages; background-thread summarization; markdown log in repo; git auto-commit per turn 16, 27SQLite + file-backend; versioned whole-file JSON envelopes; automatic compaction by default plus manual /compact (was fake pre-CLINE-2503) 37, 45SQLite sessions.db + JSON blobs; full Recipe persisted on session record; explicit cross-session recall (chatrecall + SQL FTS); user_visible/agent_visible flags 40Rollout JSONL ~/.codex/sessions/YYYY/MM/DD/ (14 RolloutItem variants) + SQLite index; fork 3 modes (Copied/CopiedDeferred/Referenced); cross-session LLM memory extraction ($CODEX_HOME/memories); resume = client-side rebuild 33, 34JSONL EventLog per event; pluggable condensers; server base_state.json resume; no cross-session recall 49, 60SQLite via Drizzle/Effect (WAL); no in-memory conversation state across turns — working set re-read each iteration; per-iteration compaction.isOverflow → summarize head, keep token-budgeted tail; compaction.prune() forked in background 20, 21SQLite/WAL SessionDB (~30 mixins: sessions, messages, FTS5, titles, timeline); FTS5 with custom CJK bigram tokenizer; session_search cross-session recall; memory as provider ABC (builtin, honcho, hindsight) 21, 22, 23, 29Two SQLite DBs via node:sqlite (no external server): shared state DB (append-only session_state_events, per-agent cursors) + per-agent DB (session_nodes → session_windows → transcript_events, append-only, compressed blobs, FTS); layered memory — MEMORY.md seed, vector/keyword index, active-memory proactive surfacing, dreaming/curation 35, 36JSONL session recording under ~/.gemini/tmp//chats/; legacy compression (0.5 threshold, two-pass probe) + opt-in ContextManager; 4-tier GEMINI.md memory; background session-mining extraction service 43, 44, 46, 48Per-step .traj JSON (trajectory steps, full history, info, replay config, env); no compaction, no cross-session memory; trajectories double as replay inputs and few-shot demos 16, 22JSONL .jsonl under ~/.qwen/projects//chats; 3-tier compaction (warn/auto 0.85/hard, in-place); QWEN.md + AGENTS.md + QWEN.local.md; MemoryManager (project/user/team layers) - per-query extraction + gated dream, no vector DB 62, 63, 66, 68The archive is the memory: run-id list, patch-only storage (parent_commit chain), per-node metadata.json + self_evo.md transcripts; per-generation JSONL checkpoint 5, 6, 3Event-sourced JSONL memory (user + project scopes) with projection rebuild and 0.6-similarity dedup; an LLM extraction pass runs after every interactive turn; sessions are JSONL directories resumed by full replay, with a fresh-session fallback on replay failure 31, 32, 34The append-only session event log (format v4) is the only state: per-session directories of checksummed zstd JSONL under ~/.dsh/sessions, with torn-tail recovery; compaction triggers at ≈0.8 × window; no built-in cross-session memory — opt-in session search, or third-party memory over MCP 34, 35, 36LangGraph checkpoints via a caller-supplied checkpointer (none by default); files live in a state channel via the default thread-scoped StateBackend, or Store/Filesystem/Composite backends; summarization is a non-mutating event with evicted history offloaded to /conversation_history/*.md; tool results are evicted at 20k tokens 40, 35, 34, 20Per-cwd session directories under ~/.grok/sessions; the session-state archive is the chat history (chat_history.jsonl), enriched with git root and remote URL for traces; a separate memory store whose archive upload is skipped (with the skip recorded) when the session registry is disabled 41, 27, 37The improvement harness: a per-(run, mode, domain) library storing each adopted harness as its whole tree plus EXPERIENCE.md (why, per-edit effects, cue/lesson/evidence/confidence); a content-addressed session cache makes sweeps resumable 49, 22, 35Team memory is the board: typed gists (100/300-char caps, detail behind a G<n> label for unfold), a 2,000-entry live view over fully retained MySQL history with boolean grep; claims expire (1h), patch summaries supersede, FAIL invalidates; individual memory is the persisted Copilot session plus archived HOME/workspace 8, 32, 34One SQLite Store (WAL): Triggers, Threads, Decisions, Tickets, Assignments, receipts, cursors and a durable effect queue in the same file; Ticket stage derived, never stored 42, 44, 24SQLite session store (messages, events, todos and the goal row) shared by all surfaces, with resume/fork; project memory is file-based (a MEMORY.md index under 200 lines over topic files) written by a sandboxed memory agent loop and consolidated by a dream pass, recalled by prefetch mid-turn; micro + auto compaction bounds context 17, 25, 26The append-only PostgreSQL event log is the session: per-session sequence, messages as projections, resume as a fold of the tail; cross-session memory is file-shaped (organization Memories, agent/user scopes, Knowledge mounts); no wall-clock ceiling 6, 28The SQLite store is the session: every message, tool call and result a row, persisted before execution; threads fork with git checkpoints; rolling summarization at 90% of context; carry-over is files and the board 37, 39
6Reasoning/planningThinking levels forwarded; no planner/sub-agents (omitted) 29, 32Architect = sequential 2-model delegation with user gate; no autonomous sub-agents 24plan/act modes (differ by one tool); sub-agents + teams in SDK/CLI, disabled in VS Code 35, 38, 45GooseMode (Auto/Approve/SmartApprove/Chat); summon sub-agents (forced Auto, 25 turns, no nesting); recipes as declarative task programs; in-process cron schedules (always Auto) 29, 44, 46, 43Sub-agents, two generations (V1 multi_agent_v1.*, V2 plain names) via multi_agent_version, agent_max_depth; update_plan tool; Guardian LLM auto-reviewer in the approval chain 30, 22, 23Critic + iterative refinement gates termination; /goal LLM judge loop; sub-agent frontmatter defs 34, 30, 63Subagents as full child sessions with nested runLoop (own history, own SQLite rows) via task tool; background tasks inject completion as synthetic user messages; no separate planner 22, 23No separate planner; subagents via delegate_task (250 iterations, tool grant carved from parent); post-turn background review fork proposes skill/memory writes; curator auto-transitions skill lifecycle on inactivity (7 days; pin/archive/consolidate, never delete) 9, 11, 13, 26Subagents via the AgentHarness pluggable interface (runAttempt) — gateway can dispatch turns to non-OpenClaw harnesses; tool-loop recovery detector; retry budgets (BASE_RUN_RETRY_ITERATIONS = 24); post-run continue/handoff directives 2, 12, 26No separate planner; subagents via invoke_agent (isolated registries, mandatory complete_task, no nesting); maxTurns 30 default; write_todos tracking 53, 56, 57, 24No planner, no sub-agents; model's own discussion text parsed as thought; AskColleagues samples N completions and debates; reviewer/chooser score whole attempts and retry 19, 12agent tool (legacy task alias); first-class Plan Mode (enter/exit, headless/ACP entry); Agent Teams (mailbox, task board, persisted teams, leader permission bridge); checkpointed resumable workflows; native LSP 75, 76, 77, 78No planner/sub-agents; fixed o1 diagnoser (never improved); the rewrite is done by the current parent agent — the one recursive mechanism; post-hoc −2..2 score gates nothing 13, 20Plan mode with code-enforced read-only gates and an accept modal; persistent goals (goals.local.json) with a continuation loop and self-attested, floor-checked completion (provenance: 'reported'); sub-agent loop copies (cap 10, depth 3); OS-process peer teams 47, 29, 37, 17No separate planner: the planning surface is tools from the generated 2,773-line catalog — todo_write, goal tools, exit_plan_mode, scheduling — plus a subagent tool with interrupt/list/send-message controls 20No planner and no todo tool in the default stack — write_todos exists only in the OpenAI Codex profile (LangChain TodoListMiddleware); decomposition is delegated to subagents via task; optional RubricMiddleware grades the transcript with a grader sub-agent until satisfied or capped 22, 44, 16A todo tool and plan mode (Plan is one of the six permission modes) structure the work; decomposition leans on subagent delegation rather than a separate planner 18The search is the planning: contrast-driven editing (every edit traces to a trajectory moment; divergences first, then repeated failures, then risks), dimension-split proposals, composition over candidate pools, final diversity measured by pairwise line-Jaccard 8, 7, 10No planner: emergent self-selection — the task issue is unassigned, workers open their own issues and reserve areas with expiring CLAIM gists, collisions settled by DM; verification is prompt-prescribed comparison against the reference, and board 'verified' status is a wording check 3, 9, 35No planner: one Ticket per accepted request; the assessor judges admission only, decomposition inside the worker Session is dsh's (subagents under the standard preset) 20, 28No separate planner: TodoRead/Write and plan mode structure work; decomposition via subagents and agent-authored dynamic workflows; long-horizon planning is the Goal system — a persisted objective continued turn-over-turn, with completion judged by a separate verifier (evidence per requirement, no proxy signals), not by the working model 13, 14, 18No separate planner: the reason–act loop plus session tasks/sub-agents, schedules and journaled timers; long-horizon work is long-lived sessions woken by timers, triggers and channels 19Modes act / plan / explore (plan mounts the worktree read-only, forbids writing, requires approval before task creation); subtask trees — children before parents — are the decomposition; no separate planner 23
7ExtensibilityTS extensions, hooks at every seam, MCP, skills 3142 closed slash commands; model-settings YAML; no plugin API, MCP, or skills — configuration, not code 32, 33, 34Richest so far: AgentRuntimePlugin, 7-callback hooks, file hooks, skills, MCP, sub-agents 4, 36Broadest so far: MCP extension configs (4 transports), 12-event plugin hooks, recipes, schedules, sub-agents, skills, custom providers, the Provider trait 21, 42, 46, 43, 35, 34ToolExecutor trait + ToolContributor; MCP wrapped (McpHandler, client-only); skills = prompt injection; hooks (12 events, precedence #1 in approvals); plugins (manifest); closed TUI slash commands; user-declared providers 23, 26, 27, 28, 29, 31Skills, 3-kind hooks, plugins, MCP, sub-agents, marketplace, extensions, condenser, router, critic — 12 axes 70, 72, 78tool.definition plugin hook; MCP servers contribute tools dynamically; skills assembled into the system prompt; subagents; permission rulesets; Effect Tag DI throughout 10, 27, 4Providers as lazily-discovered plugins; pre_tool_call + fail-open transform_tool_result hooks in the dispatch funnel; memory provider ABC; runtime skill writes via skill_manage (SKILL.md + frontmatter, agentskills.io-compatible) 13, 15, 23Capability-typed plugin system (api.registerX — providers, channels, embeddings, speech, media, web fetch, migrations); ~100 bundled extensions with openclaw.plugin.json manifests; lazy loading (Telegram activation.onStartup: false); skill authoring as first-class flow 3, 38, 39MCP servers (namespaced mcp_ tools); skills (two-stage activate_skill); 11 hook types (command + runtime, can block/rewrite/replace chunks); extensions contribute servers/skills/agents/hooks/policies 60, 64, 49Config-driven: new ACI = bundle dir + YAML line; parser/processor/problem-statement protocols; 13-point AbstractAgentHook + EnvHook/RunHook; Pydantic extra="forbid" 18MCP (least-changed); 22 hook types in 4 kinds (command/http/function/prompt); skills can register session-scoped hooks; Auto-Skills weekly curator; Claude Code plugin converter 71, 72, 73, 80New tool = file in tools/; new sampling method = one CLI string (bugged); policies keep_all/keep_better; subsets are JSON; prompt modules 18, 4, 8, 16Cross-vendor SKILL.md skills, including LLM-generated ones written to .autohand/skills with provenance metadata and hash-based refresh; a community registry guarded by a regex security scanner (install path only); extension packages run in-process through a trust-gated dynamic-import runtime 3, 39, 40Cordis plugins for everything above the kernel — the loop included; an apply contract with schema-validated config, inject/provide wiring and effect disposers; layered YAML patch composition (bundles, profiles, presets, overlays); npm-installed profile plugins; Creator mode defines plugins at runtime inside a node:vm realm 6, 7, 39, 41LangChain middleware API: replace-by-name stack surgery with protected scaffolding (FilesystemMiddleware and SubAgentMiddleware cannot be excluded); custom backends via BackendProtocol; declarative, compiled, or remote (LangGraph Platform) subagents; Agent Skills with progressive disclosure; public profile registration 8, 9, 43, 41Custom agent definitions plus a feature registry whose resolution order recurs everywhere — requirements pin → env → config → remote settings → default; the remote tier is fetched from the proxy's GET /v1/settings and can even carry a remote sandbox kill switch 3, 10BenchmarkAdapter protocol + BenchSpec values (install mode, leak globs, subagent policy, deliverable serving); a new substrate needs a SurfaceSpec, install modes and a trajectory renderer; two prompt packs (adapt, tts) 55, 58Team size as a Compose-generator parameter (one worker/router pair per agent); tasks as ProgramBench IDs; the prompt set is file configuration treated as part of the measured apparatus; a new single-agent harness needs an ACP entrypoint/bridge pair — only Copilot ships 5, 51, 52The bundle is the extension: a Cordis patch into dsh (3 plugin inserts, 2 presets, injected web client); new Sources via the SourceKind contract + docs/008 cookbook 2, 5, 53A plugin marketplace: Official Marketplace (builtin-seeded + sha256-checked CDN zips), personal git/GitHub/URL/local sources, Claude-marketplace compatibility; manifests carry commands/agents/skills/hooks/MCP servers/config; UI plugins render interactive MCP Apps panels co-edited by user and agent (desktop-local at this pin); skills via bundles/plugins/lockfile; 7 lifecycle hook events behind a workspace trust/review flow 36, 37, 23Capabilities are the extension unit (~60 built in, config-selected); MCP servers with live authorization; agent packages and GitHub-synced sources (two-way in 0.49.0); channels (Agent API, Slack, webhook, AG-UI, A2A); embeddable framework crate 3, 50Seven extension types (lsp, ui, css, i18n, agent, llm, tool), git-pinned; isolation by kind — opaque-origin iframes, per-extension gVisor sandboxes, wazero adapters, pure data; MCP pinned to one protocol era 41, 55
8InterfacesTUI / print / RPC / SDK — all event subscribers 9prompt_toolkit CLI; --message one-shot; streamlit GUI; imperative rendering, no event stream 20VS Code webview over proto-bus gRPC (22 svcs/224 RPCs) + CLI host + npm SDK re-export 26, 39Rust CLI REPL + Electron desktop + ACP bridge + Telegram gateway; loop emits AgentEvents; uniffi Python/Kotlin bindings via goose-sdk 20, 45, 41All RPC: TUI + exec + daemon are app-server (JSON-RPC v2) clients; exec is in-process; separate exec-server for remote/foreign-OS 2SDK / agent-server REST+WS / ACP host mode / TS client; all consume the event stream 6, 66SolidJS TUI / serve / ACP — all subscribe to the session bus (Permission.Asked, message/part updates); SQLite as the shared substrate 24CLI + multi-tenant messaging gateway (Telegram/Discord/WhatsApp/Slack/Signal) with session-key namespaces and pairing-code flow + TypeScript TUI + ACP 4, 20Channel-first: ~25 channel adapters (Telegram built with createChatChannelPlugin(); WhatsApp, Discord, Signal, Slack) running in-process in the gateway; CLI and web UI are secondary surfaces 1, 20Ink TUI (interactive) + gemini -p non-interactive; ACP sessions; A2A server; programmatic SDK; VS Code IDE companion 67CLI subcommands (run, run-batch, run-replay, traj-to-demo, ...); textual inspect + web inspector trajectory viewers; Flask+SocketIO API + React frontend 17Ink TUI; qwen serve ACP daemon (HTTP+SSE+WS) + @qwen-code/acp-bridge; 11 channel adapters spawning headless qwen --acp; web shell; Tauri desktop; VS Code companion; TS/Python/Java SDKs 83, 84, 85, 86, 88CLI only; analysis/visualize_archive.py rebuilds the tree, regenerates eval commands 2, 6, 16Ink TUI; one-shot/pipe CLI with JSON-schema output enforcement; ACP over ndJSON via an in-process AgentSideConnection; JSON-RPC over stdio with a defined method table for VS Code and external drivers 41, 42, 43No interactive CLI TUI — a profile-boot CLI (web / headless / sdk / sdk-minimal / acp); the Web UI is the primary surface (default port 3080); headless one-shot prints the final answer on stdout; ACP is an automation-only subset; a JSON-RPC SDK server backs TypeScript and Python SDKs 42, 43, 44, 45Library first — the product is a compiled LangGraph graph, and invoke/stream are the runtime's; sibling packages: Deep Agents Code (dcode, client/server terminal app, TUI + headless), a deepagents-acp server, and Talon, a long-running host with messaging channels, cron, and SQLite checkpoints 45, 46, 47, 12Full-screen TUI; headless -p with JSON/streaming output; ACP over stdio plus a token-guarded local server; leader mode backed by relay and gateway WebSocket endpoints for remote control 12CLI suite only: harness2 (sweep), harness2-judge, -report, -setup, -check, -demo, -bridge; results as runs/ trees with summary/selection/judged JSON; a deterministic no-model demo exercises the full workflow 59No team UI: Gitea, Mattermost, the board's HTTP/MCP surface, and the runner's CLI/Make lifecycle; operators watch the same Gitea/Mattermost the agents use; results are exported committed main HEAD plus sealed per-worker shutdown archives 37, 44Proactive ingress: GitHub (issues/PRs/reviews/CI/releases) and Feishu chats/DMs (disabled by default), both polled; egress is four gated reply kinds via the Outbox; a panel whose stages put 'needs a person' first 55, 56, 32Three surfaces over one runtime: Electron desktop (updater, embedded browser, computer use), browser UI served by a local host (also zcode --web; token auth for non-local binds), terminal TUI/CLI under one zcode command; remote triggering from WeChat/Feishu/Telegram/webhook bots drives the same task flow; conversation sharing with a public-projection export 1, 2, 32API-first and headless: management REST API + the stable Agent API (one agent per channel, agent keys, SSE, question/approval answers, per-caller spend limits); same shapes on framework serve hosting; REST for writes, SSE for reads 50, 55One surface: the Svelte 5 PWA (boards, chat, diff review, terminal) over REST + WebSocket from the same binary; a narrower bearer-token API; the PWA is also an offline client (IndexedDB mirror + write queue) 50, 51
9Failure handlingAuto-retry, truncation guards, abort; no iteration cap 21, 26, 10Exp-backoff retry (60s per-attempt cap); no retry on context exhaustion; malformed edits reflected (≤3); lint/test confirm loops 7, 18Provider retry 3×; output-limit recovery 3×; loop detection 3×/5× (reactive); mistake tracker 6; no host iteration cap 9, 14, 15Three-layer retry (provider pre-first-item ≤3, recipe RetryManager, micro-retries); max_turns=1000; repetition guard inert (registered None) — the bound is turns, not loops 7, 9Stream retries 5 (cap 100); WS→HTTP fallback resets counter; unbounded connection retries (5s→60s); no loop detection by design; tool errors become failure results, never break the loop 3, 9, 10Tenacity retries; condensation recovery; stuck detector; corrective nudges; hook fail-open 56, 60, 61, 73LSP diagnostics appended to edit/write output (errors only, cap 20/file) — model self-corrects next turn, no harness retry logic; permission deny fails fast; shutdown rejects pending asks closed 16, 17, 18, 19Overflow vs truncation as separate recovery verdicts; turn-start proactive compaction; identical-call loop guardrails; denial breaker counts approval refusals; curator never deletes, only archives 25, 18, 12SQLite ingress queue with claim leases, per-lane serialization, retry, dead-letter, stall watchdog (at-least-once ordered delivery); auto-retry with exponential backoff (rate-limit/server errors — context overflow routes to compaction instead); reply dead-letter + reconciliation 24, 17, 27Typed Retry/Error turn events; loop detector aborts repeated patterns; hook failures non-fatal (fail-open); taint-risk escalation forces ASK_USER on build-file edits 9, 18, 51, 22Format/blocklist/syntax errors → silent requery (≤3) → exit_format; tenacity on API calls; error autosubmission diffs the tree into /root/model.patch - a failed run still submits something 10retryWithBackoff (7 attempts, 1.5s→30s) + unattended infinite-retry mode; stream-transport retry allow-list + watchdogs; two-tier loop detector with result-aware guards; cross-restart session recovery with synthesized tool responses 89, 90, 91, 92Per-child 1.5h timeout + cancel/log; a generation never hard-fails; JSON extraction ×3; tool errors as strings; compile gate drops crashed children; no token/dollar accounting 3, 13, 17, 18Repair over termination: loop/reflection guards, deferred-action recoveries (≤2) and truncation repairs (≤3) all attempt in-loop fixes first; iteration exhaustion produces a summary result (reason: 'iteration_limit') instead of a hard failure 13, 14, 15, 11Fail-closed throughout the tool path: an approval-answerer failure resolves unavailable → blocked; no enforcing sandbox backend → SANDBOX_UNAVAILABLE rather than an unconfined run; torn-tail log recovery on open; a provider-confirmed context-window error triggers a maximal-reduction compaction retry 24, 25, 35, 17Dangling tool calls left by interrupted runs are repaired on resume with synthetic error results; invalid assemblies fail at construction (protected-middleware exclusion, permissions+execution NotImplementedError, task-argument validation); when history offload fails, summarization degrades to an unrecoverable summary with a warning 14, 31, 48, 35A server-side doom-loop policy (the x-grok-doom-loop-check header) drives confident-signal resampling in the sampler; spilled upload queues are reconciled at startup — re-enqueued or purged by the current privacy verdict — and the coding-data opt-out itself defaults to opted-out 15, 36, 31Dead rollouts recorded, never raised; an invalid proposal gets one retry with the rejection fed back, then the stage inherits the current harness (fell_back); selector failure falls back to a delivered final; judge failure is None — excluded from the denominator, never a zero; resume is content-verified by harness fingerprint 6, 13, 26Durable event delivery: per-agent dedup, batches acknowledged only after the turn completes, retry with backoff, stuck sending rows recovered on restart, session reloaded by id; bridge disconnects use native session/cancel with a settle wait; silent turns earn a forced-write nudge 11, 24, 27, 43Durable effects (retry, failure threshold 3); interrupted Assignments resumed with a recovery note; expired Evals requeued at most twice; sends idempotent by receipt + platform marker 44, 52, 40Goal continuation is conservative: defers to background tasks, verifies before continuing, stops on verifier failure without a next action, re-reads goal state after verification so a user Stop wins; verifier JSON parsing fails open (recorded) rather than trapping a goal; compaction rapid-refill circuit breaker; turns are cancellable commands; provider configs fall back to last-known-good 19, 20, 4Lease expiry (~10s TTL) and takeover by fold; fenced appends refuse stale holders in-transaction; unfinished calls rerun only when declared safe, else interrupted, with a stable idempotency key to MCP servers; poison guard seals turns whose workers keep dying; stall watchdog; cancel targets one turn by inbox position 10, 11, 34Provider retry (3 attempts / 3 min, rejections never retried); failure limit with optional loop-breaker rewind; runs rebuild from rows after a crash; merge conflicts interrupt, never cancel; memory supervisor pauses the cheapest task 13, 21
10Security modelProject trust + extension hooks; no built-in approval UX 24, 33Chat-file edits auto-apply; prompts only at boundaries; git auto-commit + /undo; no sandbox 30Finest-grained: per-tool policies + webview UI + diff previews; commands prompt by default; no sandbox; per-turn stash checkpoints 3, 22, 40Modes × permission.yaml × 5-inspector chain (security can only escalate); LLM judge for SmartApprove (UNTRUSTED-labeled, fail-closed); Always-Allow withheld on security warning; strict headless; no undo 29, 30, 31, 32, 33, 28Strongest: 4-layer sandbox (Starlark exec-policy → PermissionProfile → OS backends: Seatbelt / bwrap+landlock+seccomp / Windows PSEC → MITM network proxy); per-action approvals (sealed enum); hooks → Guardian → user; AskForApproval 4-mode ladder; no undo 4, 15, 16, 17, 18, 21, 22Risk labels + confirmation policy + defense-in-depth rails; no OS sandbox in the loop 44, 58, 88Permission gate per tool call: layered rulesets (session, approved, agent config), last-matching-rule-wins, default ask; ask parks on a Deferred until the user replies; answering always appends to the approved ruleset; no OS sandbox in the loop 16, 17Per-session gateway approval queue + YOLO-mode bypass + denial breaker; ACP edit approval (ContextVar-bound); subagent tool grants carved from parent, never widened; webhook payloads restricted to safe tool subset 18, 27, 19Staged admission verdicts (ingest → classify → preflight → resolve → assemble → dispatch → finalize); explicitly ordered approval chain (ordering is behavior); use-time authority gate bound to the run's delegated authority; hashed-receipt audit; approval prompts as native channel UI (Telegram inline buttons) 4, 31, 32TOML policy engine (tiered priorities, first-match-wins) + confirmation bus; 4 approval modes; per-OS sandboxes (Seatbelt/bwrap/Windows tokens); Conseca LLM-written policy (opt-in, default off) 29, 34, 40, 39Sandboxing is the Docker container via SWE-ReX - agent runs as root inside; zero human approval prompts, blocklist only; hardcoded Flask secret - researcher threat model 20AUTO default: rule-string PermissionManager (deny > ask > allow > default) + fail-closed LLM classifier + deterministic destructive-command guard + protected writes; confirmation bus gutted; Linux-only bwrap/landlock sandbox; YOLO settable in settings.json 36, 43, 47, 37Per-task Docker but unhardened — no network/memory/cap limits; zero approvals, no HITL; operator API keys as env vars; test-patch stripping is the sole hard anti-hack; full lineage traceability 19Unbypassable security blacklist checked first (and re-checked); fail-closed dispositions — default collapses to prompt, unknown to deny; permission decisions stored as patterns; workspace trust keyed by a SHA-256 over the {hooks, mcpServers} config; extension runtimes are trusted in-process code — no sandbox 25, 26, 28, 40Two-knob permission presets (sandbox mode × approval policy: read-only / workspace-write / danger-full-access) pinned per session in the log; per-call OS sandboxing — bubblewrap → Landlock, Seatbelt, Windows ACL (reported partial) — with a one-call approval-gated escalation ladder; plugins run in-process outside the sandbox; session-log upload to the official API is default-on (switchable) 23, 26, 29, 30The backend is the boundary: the default StateBackend cannot execute at all; LocalShellBackend runs host commands via shell=True, unsandboxed, under extensive docstring warnings; real isolation only via BaseSandbox partner backends; first-match glob permission rules (allow/deny/interrupt) fence the fs tools — symlink-resolved, listings filtered — but do not cover execute 28, 29, 24, 31Six permission modes; authorization runs hooks → rules (deny > ask > allow) → per-project grants → read-only auto-approvals → mode policy, with auto mode decided by an LLM transcript classifier; an opt-in whole-process OS sandbox (Landlock/Seatbelt) is applied at startup before the agent boots, off by default; whole-repo collection is stubbed out at this pin — both producers return 'unavailable in this build' 19, 20, 21, 29Score-blindness by construction (RunView carries no score) plus tripwires: grader-verdict marker scans on every evidence/harness/library tree, per-benchmark answer-key leak globs, anonymized selection; proposer sessions in fenced temp workspaces with API keys stripped from the environment; the executor side is open by design — network unrestricted, Codex approvals/sandbox bypassed, mitigation delegated to operator egress filtering and disclosed in the docs 15, 27, 53No runtime approvals (--no-ask-user) and zero-approval self-merge by design; guardrails are subtractive (60-entry MCP deny list) and credential-scoped (per-worker tokens from an auth-gated secret service, board membership checks, workers as UID/GID 10000); offline worker networks and an execute-only reference binary in the benchmark condition 21, 38, 46, 48Admission gate + assessor judgement up front and a Mandate per Ticket; after accept, workers run without approval as the operator's OS user at danger-full-access — blocked commands are PATH shims, containment is the dedicated account 34, 30, 66Six collaboration modes (plan/build/edit/yolo/guarded/auto) with a per-tool permission service (risk, side-effect scope, rulesets, plan-mode policy) and hook-visible PermissionRequest events; containment rests on that layer plus bash command analysis — no OS sandbox in the core at this pin; bots bound to a single provider user id with workspace/command allow-lists and credential-service secrets; workspace checkpoints are local-only at this pin, telemetry endpoints build-gated (empty = off), OTLP traces environment-gated 11, 22, 33, 38, 41Org-scoped multitenancy at the API layer; agent keys scoped to one channel's own sessions; hard approval gate keyed on declared tool risk (normal/protective/off), fingerprint-bound one-off approvals answered against the emitted event; scoped write-only credentials; envelope-encrypted secrets; egress policy; workers hold no database credentials 16, 37, 42gVisor (runsc) per task via rootless Podman, --cap-drop ALL, no-new-privileges; worktree rw with its .git pointer pinned read-only, project .git read-only; --network none an explicit per-project choice; missing bridge refuses tools; unsandboxed needs DANGER_ZONE=1; passkey pairing 15, 17, 48

Columns