ReferenceReference
Frontier comparison
What GEODE borrows from Claude Code, Codex CLI, OpenClaw, and Hermes, and where it differs. The reference entry point for GEODE's position in the lineage.
On this page
System-level positioning
GEODE is a synthesis: each row below borrows from at least one frontier system. Patterns explicitly cited in source: Claude Code's while(tool_use), Codex CLI's sandbox-default, OpenClaw's Policy Chain and Lane Queue, and Karpathy's P1-P10.
| Axis | Claude Code | Codex CLI | OpenClaw | Hermes | autoresearch | GEODE |
|---|---|---|---|---|---|---|
| Purpose | Coding assist | Code automation | Multi-channel gateway | Self-learning agent | Autonomous ML loop | Long-running autonomous execution |
| Domain | code | code | chat routing | open-domain | ML loop | General purpose: research, analysis, automation, schedules |
| Main primitive | while(tool_use) | sandbox + approve | gateway + lane | skill loop | branchless dumb platform | while(tool_use) AgenticLoop + LaneQueue |
| Layering | single CLI | single CLI | gateway-centric | agent + skills | 3-file contract | 5 layers: Model / Runtime / Harness / Agent / Self-Improving |
| Memory | CLAUDE.md hierarchy + auto memory (~/.claude) | hierarchical AGENTS.md + memories pipeline | per-channel store | persistent + skill catalog | program.md | 5-tier: Identity / User Profile / Org / Project / Session (core/memory/context.py) |
| Self-verification | none | sandbox | policy chain | none | ratchet | Petri adversarial audit + margin gate + prompt-hash ratchet |
| Automation trigger | hooks + scheduled cloud agents | lifecycle hooks (no cron) | cron + standing orders | skill auto-generate | overnight loop | hook events + scheduler + the auto-trigger sidecar |
| Multi-LLM | Anthropic models only (API/Bedrock/Vertex backends) | OpenAI-first + model_providers extension (incl. Bedrock) | 9 model API families | Anthropic-centric | (single) | Four explicit routes (Anthropic / OpenAI+Codex / OpenRouter / GLM), separating direct paths from inference-router identity |
| Sub-agent | Task tool | thread fork (spawn_subagent) | spawn + announce | parallel delegate spawn | none | Borrowed: Task tool + OpenClaw Spawn+Announce (core/agent/sub_agent.py) |
| Sandbox | bash sandbox (opt-in) | OS-level | gateway isolation | none | constraint loop | 6-layer PolicyChain (core/tools/policy.py) |
The combination only GEODE ships
- An explicit self-improving layer. The fifth layer mutates a scaffold of seven behaviour kinds, selects via Petri 22-dim audits and a margin gate, and preserves lineage as a git champion chain (
evolve/scaffold_search/). No weight or parameter updates anywhere; the mechanism is selection. - MCP in both directions.
core/mcp/is the client that attaches external MCP servers, andgeode-mcp(core/mcp_server.py) is the first-class server that exposes GEODE itself as a tool to external hosts. Codex CLI also ships both directions (mcp-server plus mcp_servers); the difference is that GEODE additionally exposes self-improving loop state (self_improving_*) as tools. - No-fallback default.
[model.fallbacks]ships empty: a primary failure surfaces as an honest error, and cross-provider chains are opt-in via~/.geode/routing.toml(core/llm/router/calls/_failover.py). - ChatGPT Plus JWT verification. The
chatgpt_plan_typeclaim is extracted from the access token at OAuth time and embedded in the plan record (core/auth/oauth_login.py); no separate API call for the entitlement check.
Prompt definition layer
| Axis | GEODE | Hermes | OpenClaw | Claude Code |
|---|---|---|---|---|
| Source location | core/llm/prompts/*.md (external markdown) | agent/prompt_builder.py (Python const) | src/agents/system-prompt.ts (TS const) | src/core/system-prompt.ts (TS assembly) |
| Build time | Hashed at module import, assembled per turn | Session start (cached) | Per-call modular | Per-turn dynamic |
| User memory | 5-tier ~/.geode/memory/ | Frozen JSON snapshot | Workspace HEARTBEAT.md | CLAUDE.md 4-tier + auto MEMORY.md |
| Skill format | XML <available_skills> (core/skills/skills.py, substituted via {skill_context}) | XML <available_skills> | XML <available_skills> | SKILL.md markdown + JSON manifest |
Hashing and integrity
| Axis | GEODE | Hermes | OpenClaw | Claude Code |
|---|---|---|---|---|
| Algorithm | SHA-256[:12] | None | SHA-256 (full) | None (not found in source) |
| Pin / CI gate | Yes: _PINNED_HASHES + verify_prompt_integrity (core/llm/prompts/__init__.py) | None | Detection only | None |
| Normalization | UTF-8 / json sort_keys | mtime + size manifest | CRLF strip + sort + lowercase | n/a |
Prompt caching
| Axis | GEODE | Hermes | OpenClaw | Claude Code |
|---|---|---|---|---|
| Anthropic ephemeral | Yes: static/dynamic boundary split | Yes: system_and_3 | Yes: boundary marker | Yes |
| Boundary marker | PROMPT_CACHE_BOUNDARY = <dynamic_context> (core/agent/system_prompt.py) | None | <!-- OPENCLAW_CACHE_BOUNDARY --> | SYSTEM_PROMPT_DYNAMIC_BOUNDARY |
| Messages history cache | Yes: rolling breakpoints on recent user messages (apply_messages_cache_control, core/llm/providers/anthropic.py) | Yes: last 3 | Yes: last user message | Yes: last user blocks |
The other half of cache stability is omitting synthetic reminder messages. Date and runtime rules live in the dynamic system region in system_prompt.py, while message history appends only real turns and remains an exact prefix across calls.
Async runtime discipline
Measured directly from workspace sources after the 2026-06-12 event-loop pollution incident (v0.99.183~185). All three systems converge on one rule: never build a disposable event loop at runtime, and keep loop-bound resources (httpx connection pools) inside the loop that created them.
| Axis | GEODE | Hermes | OpenClaw |
|---|---|---|---|
| Loop topology | Multiple persistent loops: main serve + CLI poller + per-channel pollers (asyncio.Runner threads) | One gateway loop; channel adapters are async tasks on it (gateway/run.py) | Single Node loop + lane concurrency (command-queue.ts) |
| Thread → loop bridge | run_coroutine_threadsafe: webhook thread marshals into the main serve loop (core/cli/typer_serve.py) | run_coroutine_threadsafe: cron thread marshals into the main loop | n/a (single loop) |
| Loops in sync bridges | Zero disposable: asyncio.run only at true process edges; violations trip the run_process_coroutine canary WARNING (core/async_runtime.py) | Persistent per-thread loop cache, never disposable (model_tools.py _run_async) | n/a |
| SDK client scope | Per-loop: LoopAffineClientCache keys clients by weakly-referenced loop (core/llm/loop_affinity.py) | Bound to the creating loop, sharing its lifetime | Global (safe under a single loop) |
| Hang defense | Tool/MCP wall-clock deadlines (asyncio.wait_for) + a timing-constant coherence inequality guard | Per-tool timeouts | Lane concurrency caps |
| Regression guard | 25-test guardrail suite (async handler pins, client-cache ratchets, deadline coherence) + runtime canary | None | None |
GEODE is the only one keeping multiple loops. Per-channel thread isolation is a design choice; its cost, cross-loop sharing of loop-bound resources (the web_search instant-fail/eternal-hang incident: disposable loops per tool call × a global client cache), was closed in v0.99.183~185 with async-native handlers, per-loop clients, and deadlines. The disposable-loop residues (tool path, webhook, verify judge) are all gone, and the guardrail suite keeps them gone.
Observability
| Axis | GEODE | Hermes | OpenClaw | Claude Code |
|---|---|---|---|---|
| Primary channel | PROMPT_ASSEMBLED hook payload (core/agent/loop/agent_loop.py) | per-tool preview log (variable length) | cache-trace.ts JSONL | logEvent('tengu_*') telemetry |
| External tracing | Optional OTLP (core/observability/otel_export.py) | Langfuse plugin | Self JSONL | Self telemetry |
Security
| Axis | GEODE | Hermes | OpenClaw | Claude Code |
|---|---|---|---|---|
| Prompt-injection scan | None (open GAP) | 10 patterns + 10 invisible Unicode chars | Path/URL sanitization | Trusts user intent |
| Override policy | Append-only (caller system_suffix) | Append-only | Append-only | Priority chain |
Why GEODE was the only one to ratchet
GEODE's prompts live in markdown files. Hermes, OpenClaw, and Claude Code keep prompts as inline strings inside TypeScript or Python source. Inline strings fight a hash-based ratchet through autoformatter noise, IDE renames, and merge-conflict resolutions. External markdown makes the file the unit of change, and the hash becomes meaningful.
The cost is explicit too: every intentional prompt change pays one extra re-pin commit. In exchange, unintentional changes never ship, enforced by CI. The full shape is in Why ratchet discipline.
Moved from the GEODE repository’s documentation site. Source commit de077a4 · View the source on GitHub