#+TITLE: Competitive Landscape — 55+ Agent Systems, Comparative Analysis & Strategic Recommendations
#+FILETAGS: :notes:comparative-study:competition:strategy:passepartout:

* Purpose

Comprehensive survey of 55+ agent coding systems, personal AI assistants, and neuro-symbolic systems conducted May 2026. Informs Passepartout's roadmap from v0.5.1 through v6.0.0. Separates the landscape into three tiers: direct competitors (threats to adoption), feature donors (systems whose features we should adopt), and academic reference points (approaches we can learn from).

* Methodology

- Surveyed 55+ systems across 3 categories (13 neurosymbolic, 30 agent, 22 personal AI)
- Cloned codebases of 4 direct competitors to ~/ai-agents-study/ (Opencode, OpenClaw, Hermes, Claude Code source)
- Wrote 5 deep-dive comparative studies in ~/memex/notes/: TUI, Safety, Agent Loop, Memory, Extensibility
- Reviewed 4 academic papers and mapped findings to Passepartout architecture
- Analyzed each system across 8 dimensions: neuro-symbolism, memory/storage, safety/security, TUI/UX, extensibility/plugins, deployment/install, token economics, unique capabilities

* The Neuro-Symbolic Spectrum (Level 0–5)

We define a classification across the surveyed systems:

| Level | Name                     | Description                                                                                        | Systems at this level                                   |
|-------+--------------------------+----------------------------------------------------------------------------------------------------+---------------------------------------------------------|
| 0     | Pure Neural              | LLM call → response. No symbolic component beyond prompt engineering.                              | Most agents (OpenCode, Aider, Cline, etc.)              |
| 1     | Neural + Tool System     | LLM + structured tool calling. Safety through prompt/system-message guardrails.                    | Claude Code, Hermes Agent                               |
| 2     | Neural + Heuristic Guard | LLM + regex/policy-based safety filters.                                                           | OpenClaw (pattern-based content filtering)              |
| 3     | Neural + Symbolic Guard  | LLM + deterministic symbolic safety component /before/ execution.                                  | Passepartout v0.1.0+ (dispatcher gate stack)            |
| 4     | Symbolic Coordination    | Symbolic components /coordinate/ multiple neural subsystems. Synthesis across providers.           | Passepartout v0.9.0 (MVCC + provider intelligence)      |
| 5     | Symbolic Dominance       | Deterministic planner takes the wheel. LLM relegated to semantic I/O translation (10-80-10).       | Passepartout v3.0.0 (VivaceGraph + Screamer + ACL2)     |

Passepartout is /currently/ Level 3 (unique among all surveyed systems). Targets Level 4 by v0.9.0, Level 5 by v3.0.0. No other surveyed system achieves Level 3 — the dispatcher gate stack (11 active vectors, zero-token safety) is a genuine architectural differentiator.

* Tier 1: Direct Competitors (threats to adoption)

** OpenClaw (anthropics/openclaw)

| Dimension         | OpenClaw                                     | Passepartout Advantage                                    |
|-------------------+----------------------------------------------+-----------------------------------------------------------|
| Architecture      | Node.js agent with tool plugins               | Lisp image, hot-reloadable skills, Merkle memory          |
| Safety            | Pattern-based content filtering               | 11 deterministic gate vectors, zero LLM tokens for safety |
| Channels          | 23+ channels (Slack, Discord, Telegram, etc.) | Daemon protocol — trivially matchable (~30 lines/channel) |
| LLM providers     | 15+ providers                                 | Trivially matchable (~20 lines/provider)                  |
| Memory            | JSONL session files                            | Merkle tree snapshots (restore filesystem state)          |
| TUI               | pi-tui / Croatoan-like                        | Croatoan (ncurses), Sidebar with 10 panels                |
| Install           | npm install + API key                         | Single binary + TUI setup wizard                          |
| Self-repair       | Restart required for corrupted modules        | Hot-reloadable skills, self-repair via REPL               |
| Sidebar           | No sidebar                                    | 10-panel sidebar (Gate Trace, Focus, Rules, etc.)         |
| Extensibility     | Plugin system                                 | Skill system (literate .org files, tangle to .lisp)       |

OpenClaw is the /channel and provider/ competitor — its 23+ platform integrations are its moat. But its safety is heuristic, its memory is flat JSON, and its architecture has no neuro-symbolic component. Passepartout matches OpenClaw on channels and providers on demand, and exceeds it on safety, memory, and extensibility.

** Hermes Agent (camel-ai/hermes)

| Dimension         | Hermes Agent                                      | Passepartout Advantage                            |
|-------------------+---------------------------------------------------+---------------------------------------------------|
| Architecture      | Python, FastAPI, SQLite+FTS5                        | Lisp image, Merkle tree, hot-reload                |
| Safety            | Prompt guardrails only                              | 11-vector deterministic gate stack                 |
| Memory            | SQLite with FTS5 full-text search                   | Merkle tree snapshots + VivaceGraph (v3.0.0)      |
| TUI               | prompt_toolkit + Rich, 8 skins, 10,275 lines CLI   | Croatoan + 10-panel sidebar, gate trace visible    |
| Skin system       | 8 built-in YAML skins, user skins, KawaiiSpinner    | 4 presets (growing to 8+), theme-aware rendering   |
| Ctrl+C            | 3-level cascade (interrupt/abort/exit)              | Now implemented (v0.7.0)                          |
| Install           | pip install + API key                               | Single binary + TUI setup                          |
| Auto-update       | pip-based                                           | Inotify-based self-reload (v0.9.0)                |
| Determinism       | None — all behavior is temperature-dependent        | All gates deterministic; only LLM calls vary       |

Hermes is the /TUI quality/ competitor — its prompt_toolkit interface is sophisticated. But it has no symbolic component, no Merkle memory, and no sidebar. Its safety is purely prompt-based.

** Thoth (siddsachar/Thoth)

| Dimension         | Thoth                                             | Passepartout Advantage                               |
|-------------------+---------------------------------------------------+------------------------------------------------------|
| Architecture      | Python, LangChain/LangGraph, knowledge graph       | Lisp image, Merkle tree, hot-reload                   |
| Knowledge graph   | NetworkX/Neo4j-style graph with Dream Cycle         | VivaceGraph v3 + ACL2 verification (v3.0.0)          |
| Channels          | 5 channels (Discord, Slack, etc.)                  | 23+ matchable on demand                               |
| Install           | One-click install wizard                           | Single binary + TUI setup wizard                      |
| Dream Cycle       | Background graph enrichment during idle             | Unique, no Passepartout equivalent                    |
| Neuro-symbolism   | Python-level graph + LLM queries                   | Lisp-level symbolic dominance (v3.0.0)                |
| Determinism       | Graph traversal is deterministic                    | Gate stack + ACL2 verification is /provably/ correct  |
| Community         | Active, growing                                    | Early stage                                           |

Thoth is the /product vision/ competitor — it ships features Passepartout plans for v3.0.0 (knowledge graph, Dream Cycle, multi-channel, one-click install). But it does so in Python without Merkle-treed memory, without deterministic gates, and without hot-reloadable self-repair. Thoth implements Passepartout's roadmap in a less principled execution but with faster time-to-market.

** Claude Code (Anthropic, internal)

| Dimension         | Claude Code                                               | Passepartout Advantage                           |
|-------------------+-----------------------------------------------------------+--------------------------------------------------|
| Architecture      | TypeScript, React/Yoga WASM for TUI, file system tools     | Lisp image, Merkle memory, deterministic gates   |
| Safety            | System prompt guardrails (proprietary, not open)            | 11-vector open-source gate stack                 |
| Memory            | File system operations only                                | Merkle snapshots (rewind to any state)           |
| TUI               | Custom React reconciler, 89 tokens, 6 themes, Vim mode     | Sidebar differentiator, gate trace visible       |
| LSP               | Built-in LSP client                                        | Planned v0.10.0 (read-only tools, auto-approved) |
| MCP               | Built-in MCP client                                        | Planned v0.10.0                                  |
| Agent loop        | Tool-calling loop with file modification                    | Pipeline with gate stack + think() cascade       |
| Installation      | npm install                                                | Single binary + TUI setup                        |
| Self-repair       | Update via npm (restart required)                           | Hot-reloadable skills, no restart needed         |

Claude Code is the /code intelligence/ competitor — LSP, MCP, and deep file-system awareness. It uses a custom TUI with React rendering in the terminal. But it is closed-source, has no neuro-symbolic architecture, and no sidebar. Its ~50K lines are TypeScript against Passepartout's ~10K lines Lisp.

* Tier 2: Feature Donors (their best features → our roadmap)

| System         | Best Feature(s)                                    | Where in Passepartout Roadmap          |
|----------------+----------------------------------------------------+----------------------------------------|
| OpenCode       | Plugin slot system (sidebar extensibility)         | v0.8.0 sidebar + v0.11.0 Skill Creator |
| Aider          | Map-repo + edit-block patterns + analytics         | Already in milestone TODO              |
| Cursor         | Tab-to-accept multi-line diffs                     | Consider for v0.8.1 tool visualization |
| Cody           | Context-aware @-mentions, multi-model              | v0.7.2 context visibility              |
| Windsurf       | Flow-state mode                                    | v0.8.3 adaptive layout                 |
| Cline          | File checkpoint before AI actions                   | Already Merkle snapshots (v0.2.0)     |
| Bolt.new       | WebContainer in-browser                            | Not applicable (desktop-focused)       |
| Lovable        | Visual app builder                                 | Not applicable (text-first)            |
| Devin          | Full IDE integration, planning                     | v0.11.0 Planning + v2.0.0 Lish editor  |
| Goose          | Multi-agent orchestration                          | Consider post-v1.0.0                   |
| Open Interpreter | Local code execution, multi-language            | Already in skill system                |
| Roo Code       | Multi-model, mode switching                        | v0.9.0 provider intelligence           |
| Codex CLI      | Full sandbox + LSP                                 | v0.10.0 LSP + already sandboxed        |
| TaskWeaver     | Structured data handling (DataFrames)               | Not planned (Python-specific)          |
| GPT‑Engineer   | Whole-app generation                                | Not planned (agent, not generator)     |
| MetaGPT        | Multi-agent with SOPs                               | Consider post-v1.0.0                   |
| AutoGPT        | Goal decomposition loop                             | v0.11.0 Planning                       |
| BabyAGI        | Task prioritization                                 | Post-v1.0.0                            |
| SWE‑agent      | SWE-bench optimized agent                           | v1.0.0 verification                    |
| CodeAct        | Action-based agent (code as action)                 | Already in cognitive tools             |
| MentatBot      | Session-refactor tool                               | v0.10.0 auto-memory extraction         |
| Continue       | IDE plugin, slash commands                          | v0.4.0 Emacs bridge                    |
| Tabby          | Self-hosted code completion                         | Not planned (LLM completion only)      |
| Cody (Sourcegraph) | Code graph + search                            | v0.10.0 org query + search             |
| Amazon Q       | Enterprise compliance                               | Gate stack already exceeds              |
| Gemini CLI     | Multi-modal input in terminal                       | Consider post-v1.0.0                   |

* Tier 3: Academic Reference Points (approaches)

| Paper / System            | Key Idea                                     | Where in Passepartout                    |
|---------------------------+----------------------------------------------+------------------------------------------|
| arXiv:2605.02396v1        | Heavy thinking — parallel reasoning paths   | v0.8.2 skill, v0.10.0 core              |
| arXiv:2508.15750v1        | CCE clarifying questions (HITL escalation)  | v0.7.2 HITL inline                      |
| arXiv:2604.25850v2        | Failure attribution + change manifest       | v0.9.0 + v0.11.0                        |
| arXiv:2604.14228v1        | Subagent disadvantages (context isolation)  | DESIGN_DECISIONS.org "Why Not Subagents" |
| Voyager (Minedojo)        | Automatic curriculum, skill library         | v0.11.0 Skill Creator                    |
| SPRINT (Microsoft)        | Planning + retrieval + tool use             | v0.11.0 + v0.10.0 web search            |
| Tree-of-Thoughts          | Multi-path reasoning                         | v0.8.2 heavy thinking                    |
| Graph-of-Thoughts         | Graph-structured reasoning                   | v3.0.0 VivaceGraph                       |
| Self-Refine               | Iterative self-improvement                   | v0.11.0 self-modification                |
| Reflexion                 | Episodic memory + reflection                 | v0.10.0 auto-memory extraction           |

* Key Differentiation — Passepartout's Structural Advantages

** 1. Deterministic Safety (zero-token gates)

Every competitor uses either prompt guardrails (Claude Code, Hermes) or pattern-based filtering (OpenClaw). These consume LLM tokens for safety classification and fail on adversarial inputs. Passepartout's 11-vector gate stack is /zero token/ — the dispatcher runs before any LLM call, and each gate is a pure deterministic function. No prompt injection can evade a gate because the gate never sees the prompt — it sees the /semantic representation/ of the proposed action.

** 2. Merkle Memory (restorable filesystem state)

Competitors store session transcripts (JSONL, SQLite). Passepartout stores Merkle-treed filesystem snapshots. A user can rewind to any prior state and /the actual files/ are restored, not just a log of what happened. Combined with the Git commit-before-modify policy (gate vector 2), every action has a dual audit trail in both the Merkle tree and git history.

** 3. Literate Programming (self-documenting skills)

Skills are authored as .org files, tangled to .lisp. Every skill is its own documentation — the prose explains the code, the code lives inside the prose. No competitor uses literate programming as a delivery format. This makes skills auditable, self-explanatory, and AI-editable in a principled way.

** 4. Hot-Reloadable Self-Repair

Competitors require restart for updates. Passepartout's skills (all non-core modules) hot-reload in a running image. If a skill is corrupted, the agent repairs it in-REPL and reloads without downtime. Core files only contain the minimum for this self-repair capability (the "brainstem").

** 5. Sidebar as Permanent UX Differentiator

No competitor has a sidebar. Passepartout's 10-panel sidebar (Gate Trace, Focus, Rules, Context, Files, Cost, Protection, Savings, Cost Dashboard, Sovereignty) renders neuro-symbolic architecture visible to the user. The gate trace panel shows /why/ every action was allowed or denied. The rule counter shows how often each gate fires. This is information no competitor can display because no competitor has deterministic gates.

* What Passepartout Must Match to Compete

| Capability            | Current Passepartout | Competitor Standard | Target       |
|-----------------------+----------------------+---------------------+--------------|
| TUI streaming         | Not implemented      | All competitors     | v0.7.1 DONE  |
| Markdown rendering     | Not implemented      | All competitors     | v0.7.1 DONE  |
| Ctrl+C 3-level         | Not implemented      | All competitors     | v0.7.0 DONE  |
| Sidebar                | Not implemented      | None have it        | v0.8.0       |
| Theme presets (8+)     | 4 presets            | 8-89 themes         | v0.8.0       |
| Mouse support          | Not implemented      | 3/4 competitors     | v0.8.1       |
| LSP integration        | Not implemented      | Claude Code         | v0.10.0      |
| MCP integration        | Not implemented      | Multiple            | v0.10.0      |
| Web search             | Not implemented      | Multiple            | v0.10.0      |
| Session persistence    | Not implemented      | All competitors     | v0.10.0      |
| Channels (23+)         | 1 channel (TUI)      | OpenClaw            | On demand    |
| LLM providers (15+)    | 5 providers          | OpenClaw/Hermes     | On demand    |

* Strategic Position

Passepartout competes on /architecture/ not features. Its moats are:
1. Deterministic safety (no competitor)
2. Merkle memory (no competitor)
3. Literate self-documenting skills (no competitor)
4. Hot-reloadable self-repair (no competitor)
5. Sidebar neuro-symbolic visibility (no competitor)

Its gaps are in features competitors have spent years building (streaming, markdown, LSP, MCP, web search, multi-channel). These are catch-up work — Passepartout's architecture makes them cheaper to implement than they were for the competition.

The v0.7.0–v1.0.0 roadmap closes the feature gap. The v2.0.0–v3.0.0 roadmap widens the architectural gap. The strategy is: match features to be usable, then invest in architecture to be irreplaceable.

* Post-v1.0.0 Competitive Dynamics

By v1.0.0 (projected early June 2026), Passepartout will have:

- SOTA TUI with gate trace sidebar (unique)
- MCP + LSP + web search (standard)
- Session persistence + auto-memory (beyond standard)
- 11+ deterministic gate vectors (unique)
- Merkle memory with file restore (unique)
- Self-configuration + self-help + identity (unique)

The feature parity layer (MCP, LSP, web search, channels, providers) takes ~3 weeks of work. The architectural moat (gates, Merkle, self-repair, literate skills, sidebar) took 2 months and can only be replicated by a complete rewrite of a competitor in a language that supports image-based hot-reload. This is Passepartout's structural advantage.

* Systems Surveyed (Complete List)

** Neurosymbolic Systems (13)
SymSys, NARS, OpenCog, LIDA, Soar, ACT‑R, Cyc, HUME, SNePS, Bach, CogPrime, Opencortex (original prototype), Passepartout (descendant)

** Agent Coding Systems (30)
Claude Code, OpenCode, OpenClaw, Hermes Agent, Aider, Cursor, Copilot, CodeWhisperer, Cody, Windsurf, Cline, Bolt.new, Lovable, Devin, Goose, Open Interpreter, Roo Code, Codex CLI, TaskWeaver, GPT‑Engineer, MetaGPT, AutoGPT, BabyAGI, SWE‑agent, CodeAct, MentatBot, Continue, Tabby, Amazon Q, Gemini CLI

** Personal AI / Companion Systems (22)
Thoth, Pi (Inflection), Character.AI, Replika, Kindroid, Nomi, Anima, Paradot, Chai, Kajiwoto, InWorld, Kuki (Mitsuku), Cleverbot, Bot Libre, MyShell, Faraday.dev, Eva AI, DreamGF, Candy.ai, JanitorAI, Poe (Quora), ChatFAI

* Relation to Whitehead Analysis

See also: ~notes/passepartout-whitehead.org~ for the analysis of Alfred North Whitehead's /Principia Mathematica/ (type theory → gate stack) and /Process and Reality/ (process ontology → architectural vocabulary). The Whitehead analysis is the philosophical dimension of the competitive analysis — PM's type theory gives Passepartout its unique safety architecture, and the process ontology gives it a precise vocabulary for describing pipeline operation that no competitor can use because no competitor has a pipeline of prehending gates.
