#+TITLE: Competitive Analysis — AI Coding Agents & Personal AI Agent Systems
#+DATE: 2026-05-08
#+CONTEXT: Research for Passepartout — Common Lisp AI coding agent with TUI/CLI, REPL-driven, neurosymbolic TDD workflow

* Overview

This document surveys 30+ AI coding agents and personal AI agent systems across
the dimensions most relevant to Passepartout: safety architecture, memory
persistence, TUI/CLI interface, extensibility model, neurosymbolic or
deterministic-rule components.

* 1. Aider (Paul Gauthier)

** What it does
Git-aware AI pair programming in the terminal. Reads/writes files in your repo,
auto-commits changes. Designed for interactive chat-based coding.

** Architecture
- Model: pluggable (OpenAI, Anthropic, Gemini, local via Ollama/LM Studio)
- Tools: file read/write, git, lint/test execution, repo map (tree-sitter AST analysis)
- Memory: git history + chat history file (.aider.chat.history.md). No persistent memory across sessions beyond git.
- Safety: git-backed undo per edit; user must approve file additions; linting/tests auto-run

** Differentiators
- Repo map: compresses entire codebase into ~1024 tokens of structured context
- Edit formats: whole-file, search/replace diff, universal diff — fallback chain
- Open source (Apache 2.0), Python, highly scriptable
- Benchmark leaderboard (SWE-bench, own editing/refactoring benchmarks)

** Maturity
Production. 30k+ GitHub stars. Active development.

** Relevance to Passepartout: HIGH
--- Directly comparable: CLI-native, git-integrated, extensible via Python scripting
--- PP's .org-as-source-of-truth + tangle workflow is architecturally distinct
--- Aider has no neurosymbolic components or deterministic rule engine
--- Aider lacks memory persistence beyond git; PP's org-mode + contract-first TDD is richer

* 2. Cursor Agent Mode

** What it does
IDE-integrated coding agent inside Cursor (VS Code fork). Agent mode can plan,
read/write files, run terminal commands, and iterate autonomously.

** Architecture
- Model: Claude, GPT-4o, etc. (cursor-small model for tab completion)
- Tools: file editing, terminal, @-symbols for context, MCP support, image input
- Memory: session-only; no persistent memory across sessions
- Safety: diff view for changes, user approval on terminal commands (configurable), lint monitoring

** Differentiators
- .cursorrules for project-specific instructions
- Visual diff before applying changes
- Tab completion + agent mode + chat in one IDE
- MCP server integration for custom tools

** Maturity
Production. Widely used.

** Relevance to Passepartout: MEDIUM
--- IDE-dependent (not TUI-first). PP's Emacs/terminal-native approach is different
--- Rule system (.cursorrules) is closest thing to deterministic rules — but plain-text prompts only
--- No neurosymbolic, no persistent memory, no contract-first workflow

* 3. GitHub Copilot Agent Mode

** What it does
Microsoft/GitHub's coding agent across VS Code, GitHub.com, CLI. Agent mode
(2025) can autonomously plan, edit, run commands.

** Architecture
- Model: multi-model (OpenAI, Claude, Gemini, Haiku via Copilot)
- Tools: IDE edit, terminal, MCP, code review, code search, GitHub issues
- Memory: per-session; Enterprise can index org codebase for retrieval
- Safety: IP indemnity, code referencing filter, admin-managed MCP allowlists,
  audit logs for enterprise, opt-out for training data

** Differentiators
- Deep GitHub integration (PR review, issues, Actions)
- Multi-model access from one subscription
- Enterprise governance (SSO, audit, VPC)
- Copilot CLI for terminal-only use

** Maturity
Production. Largest userbase (millions).

** Relevance to Passepartout: LOW
--- Massive platform lock-in. No extensibility for custom workflows
--- No neurosymbolic. No persistent memory across sessions
--- Enterprise features irrelevant to PP's use case
--- The CLI component is closest competitor but lacks PP's TDD/contract cycle

* 4. Amazon Q Developer

** What it does
AWS's coding assistant across IDE, CLI, and AWS console. Code completion, chat,
security scanning, code transformation.

** Architecture
- Model: Amazon Bedrock (multiple FMs), augmented with AWS content
- Tools: IDE extension, CLI, AWS console chat, automated code review,
  vulnerability scanning, code transformation (e.g., Java upgrades)
- Memory: session; no persistent cross-session memory
- Safety: AWS IAM permissions, Bedrock abuse detection, zero data retention for
  Business tier; no training on Enterprise data

** Differentiators
- Deep AWS knowledge (VPC, EC2, Lambda, etc.)
- Automated code transformation (e.g., Java 8→17)
- Security vulnerability scanning built in
- Free tier generous

** Maturity
Production.

** Relevance to Passepartout: LOW
--- AWS-ecosystem focused. No CLI/TUI philosophy. No extensibility.
--- Not a general-purpose agent; AWS-specific

* 5. Devin (Cognition AI)

** What it does
Autonomous AI software engineer in a sandboxed environment. Plans, codes, tests,
deploys end-to-end. Acquired Windsurf (Codeium).

** Architecture
- Model: Claude Sonnet 4.5 (publicly), proprietary model claimed
- Tools: shell, code editor, browser, sandboxed compute environment
- Memory: per-session long-term reasoning; can recall context across steps
  within a task. Reports progress in real-time
- Safety: sandboxed environment, user approval on deployment, SSH key support

** Differentiators
- Full autonomy (not pair programming) — can be assigned via Slack, Jira
- SWE-bench leader: 13.86% (initial), now higher
- Can learn unfamiliar technologies, train models, do Upwork tasks
- Windsurf acquisition: now owns IDE + cloud agent stack

** Maturity
Production (GA Dec 2024). Backed by $21M+ from Founders Fund.

** Relevance to Passepartout: MEDIUM
--- Autonomous agent philosophy differs from PP's interactive TDD partner
--- WindSurf integration creates IDE dependency; PP is terminal-native
--- No neurosymbolic. No contract-first. No persistent memory (per-task only)

* 6. Factory AI / Factory Droid

** What it does
Automated code review and bug-fixing. Runs as GitHub app on every PR.
Droid bot auto-fixes issues found in review.

** Architecture
- Model: Claude/GPT (likely)
- Tools: GitHub PR integration, code review, auto-fix generation
- Memory: PR-level context; no cross-PR memory
- Safety: review-before-apply; GitHub permissions

** Differentiators
- PR-review focused (not general coding agent)
- Auto-fix generation as part of review workflow
- Enterprise-focused (code review automation)

** Maturity
Beta/production.

** Relevance to Passepartout: LOW
--- Narrow scope (PR review). Not a general agent.
--- No TUI, no memory, no extensibility.

* 7. Cline (formerly Claude Dev)

** What it does
Autonomous coding agent VSCode extension. Can create/edit files, run terminal
commands, use browser, execute MCP tools. Human-in-the-loop for all actions.

** Architecture
- Model: any (OpenRouter, Anthropic, OpenAI, Google, AWS Bedrock, local models)
- Tools: file R/W, terminal, browser (computer use), MCP servers, linter/compiler
  monitoring, checkpoint/restore
- Memory: session context; checkpoints as workspace snapshots; no persistent
  cross-session memory
- Safety: human-in-the-loop for every file change and terminal command (GUI
  approval); diff view; checkpoints for rollback; permission gates

** Differentiators
- "Add a tool" — can ask Cline to create new MCP servers on the fly
- @url, @problems, @file, @folder context markers
- Browser computer use for interactive debugging
- Checkpoint system: compare/restore workspace snapshots
- Open source (Apache 2.0), 61k+ stars
- Enterprise: SSO, on-prem, audit trails

** Maturity
Production. 61.5k GitHub stars. Rapid development.

** Relevance to Passepartout: HIGH
--- Closest architecture: extensible via MCP, CLI+editor integration, human-in-loop
--- MCP-based tool creation PP could adopt
--- No neurosymbolic rules engine; contracts are plain .clinerules text
--- Checkpoint workflow similar to PP's git-based snapshots but less structured
--- PP's .org source-of-truth + tangle is unique

* 8. RooCode

** What it does
VSCode extension for multi-agent coding. Variant/fork of Cline with multiple
agent "modes" (architect, ask, code, custom).

** Architecture
- Model: any (same provider list as Cline)
- Tools: file editing, terminal, browser, MCP, image support
- Memory: per-session context
- Safety: human approval gates, diff view

** Differentiators
- Multi-agent modes (architect plans, coder implements, ask answers)
- Custom modes with custom prompts
- Forked from Cline, similar architecture

** Maturity
Production.

** Relevance to Passepartout: MEDIUM
--- Multi-agent orchestration is interesting but VSCode-dependent
--- No neurosymbolic. No persistent memory. No contract-first.

* 9. AutoGPT

** What it does
Platform for building, deploying, and running continuous AI agents.
Classic version was autonomous GPT-4 agent; now a platform with agent builder,
marketplace, workflow management.

** Architecture
- Model: any LLM (pluggable)
- Tools: web search, file operations, code execution, block-based workflow builder
- Memory: long-term memory via vector DB (Redis/Pinecone), persistent agent state
- Safety: Docker sandboxing, user approval gates

** Differentiators
- Agent builder with visual block-based workflow
- Marketplace for pre-built agents
- Continuous/long-running agents (not session-only)
- Classic AutoGPT pioneered autonomous agent loop (think → act → observe)

** Maturity
Production. 184k stars. Classic in maintenance; platform in beta/active.

** Relevance to Passepartout: MEDIUM
--- Long-running, persistent agents concept is relevant
--- Block-based workflow builder is anti-neurosymbolic (no rules engine)
--- Python-centric; PP is Common Lisp
--- No contract-first TDD workflow

* 10. Microsoft AutoGen

** What it does
Multi-agent conversation framework from Microsoft. Agents can converse,
collaborate, execute code, use tools. .NET and Python.

** Architecture
- Model: any (OpenAI, etc.)
- Tools: MCP, Docker code execution, OpenAPI, web search, distributed runtimes
- Memory: conversation history; no built-in long-term memory; use extensions
- Safety: Docker sandbox for code execution; human-in-loop patterns

** Differentiators
- Event-driven, distributed multi-agent architecture (gRPC runtime)
- AgentChat for conversational, Core for event-driven, Studio for GUI
- MCP tool support built-in
- .NET and Python support
- Research-grade multi-agent patterns

** Maturity
Stable/Production. Backed by Microsoft.

** Relevance to Passepartout: MEDIUM
--- Multi-agent orchestration architecture is relevant
--- No TUI/CLI focus; Python/.NET
--- No neurosymbolic; no deterministic rules
--- PP could learn from AutoGen's event-driven agent patterns

* 11. CrewAI

** What it does
Open-source framework for orchestrating autonomous AI agents as "crews" with
role-based collaboration. Flows for workflow control.

** Architecture
- Model: any LLM (pluggable)
- Tools: API, database, custom tools; agent roles with specific goals
- Memory: conversation-based; no built-in persistent memory across crews
- Safety: enterprise security claims; human-in-loop patterns

** Differentiators
- Role-playing agents (researcher, writer, etc.)
- Flows (stateful, event-driven) + Crews (autonomous teams)
- 100k+ certified developers
- Enterprise-ready

** Maturity
Production.

** Relevance to Passepartout: LOW
--- Python framework, not a standalone agent
--- No TUI/CLI; not a coding agent
--- Role-based agent pattern is interesting but not directly applicable

* 12. Replit Agent (Ghostwriter)

** What it does
In-browser coding agent on Replit platform. Build, deploy apps from prompts.
Full IDE in browser with AI agent.

** Architecture
- Model: proprietary (likely fine-tuned LLM)
- Tools: in-browser IDE, file system, terminal, deployment, database
- Memory: project context within session
- Safety: sandboxed in-browser environment; Replit platform moderation

** Differentiators
- Zero setup: browser-based, no install
- Full-stack: code + DB + deploy from one prompt
- Educational focus (used in classrooms)
- Collaborative editing

** Maturity
Production.

** Relevance to Passepartout: LOW
--- Cloud-only, browser-based. Anti-TUI.
--- No extensibility. No memory persistence.
--- Educational/consumer focus, not power-user agent

* 13. Codex CLI (OpenAI)

** What it does
Lightweight CLI coding agent from OpenAI. Runs locally, writes files, runs
commands. Desktop app variant available.

** Architecture
- Model: OpenAI models (GPT-5, o-series)
- Tools: file read/write, shell execution, sandboxed environment
- Memory: session context; conversation history per session
- Safety: user approval on file writes and commands; runs locally; sandboxed
  execution

** Differentiators
- CLI-native (npm install -g @openai/codex)
- Desktop app (codex app) for richer UI
- Multi-platform (macOS, Linux, Windows)
- Open source (Apache 2.0), 81k stars, 6k+ commits
- "Sign in with ChatGPT" or API key
- Environment management for secrets

** Maturity
Production. 81k GitHub stars. Very active.

** Relevance to Passepartout: HIGH
--- Direct competitor: CLI-native coding agent
--- Same philosophy: terminal-first, local execution
--- PP differentiators: .org source-of-truth, tangle workflow, neurosymbolic
    TDD, contract-first, deterministic rules engine
--- Codex has NO neurosymbolic component, NO contracts, NO persistent memory
    beyond git, NO rule engine

* 14. Continue.dev

** What it does
Open-source AI code assistant for IDE. Chat, edit, tab-completion. Now pivoted
to Continuous AI — AI checks on PRs (source-controlled checks).

** Architecture
- Model: any (OpenAI, Anthropic, Ollama, etc.)
- Tools: IDE chat, file editing, @-references, PR checks
- Memory: session-based
- Safety: local models possible, diff-based editing

** Differentiators
- Fully open-source IDE assistant
- "Checks" — source-controlled AI reviews as markdown files in repo
- Multiple model providers
- VS Code + JetBrains

** Maturity
Production. Renamed to Continuous AI for PR-check product.

** Relevance to Passepartout: LOW
--- IDE-dependent. PR-check focus is different from PP's build-time agent
--- "Checks as markdown" concept is closest to PP's .org-based contracts —
    but far less structured. PP's contracts are machine-verifiable, not just
    prompts

* 15. PearAI

** What it does
AI code editor (VS Code fork) with integrated coding agent + chat.
Open-source, Bun-based performance.

** Architecture
- Model: any (OpenAI, Anthropic, Ollama)
- Tools: IDE agent, chat, file editing, context management
- Memory: session-based
- Safety: open source, local model support

** Differentiators
- VS Code fork (not extension)
- Bun for performance
- Free, open source
- "Context" management for prompt optimization

** Maturity
Beta/Production.

** Relevance to Passepartout: LOW
--- IDE-dependent fork. PP's Emacs + TUI is philosophically opposite.
--- No unique architecture features.

* 16. Melty (now Conductor)

** What it does
Originally Melty, now Conductor — orchestrator for running multiple coding
agents (Claude Code, Codex) in parallel on your Mac. Each agent gets an
isolated git worktree.

** Architecture
- Model: uses Codex + Claude Code under the hood
- Tools: git worktree management, parallel agent execution, review UI
- Memory: per-task git worktree; no cross-session memory
- Safety: git isolation; user reviews changes before merging
  Differentiators
- Multi-agent parallelism (not multi-agent collaboration)
- Git worktree-based isolation
- Dashboard for monitoring agents

** Maturity
Production (Beta/2025). Used at Linear, Vercel, Notion, Ramp.

** Relevance to Passepartout: MEDIUM
--- Parallel agent orchestration model is interesting
--- Doesn't replace PP's workflow; could complement
--- No neurosymbolic, no rules engine, no memory persistence

* 17. Windsurf / Codeium (now part of Cognition AI / Devin)

** What it does
AI-native IDE. Cascade agent for autonomous coding. Tab completion, agent mode,
MCP support. Acquired by Cognition (Devin).

** Architecture
- Model: multi-model (GPT-5, Claude, custom)
- Tools: Cascade (agent), Tab (completions), MCP, JetBrains plugin, Devin
  integration, Spaces (bundled context)
- Memory: Cascade sessions within workspace; Spaces for grouped context
- Safety: admin-managed MCP servers; enterprise controls

** Differentiators
- Cascade: local agent for real-time assistance
- Devin integration: cloud agent for long-running tasks
- Spaces: bundle agent sessions, PRs, files around a task
- Agent Command Center: Kanban dashboard for agents
- JetBrains plugin (targets non-VS Code users)

** Maturity
Production. 1M+ users, 4k+ enterprise customers.

** Relevance to Passepartout: MEDIUM
--- IDE-dependent (VS Code fork + JetBrains plugin)
--- Cascade + Devin hybrid local/cloud model is architecturally interesting
--- No neurosymbolic. No deterministic rules. No contract-first.
--- Spaces concept (grouping context around a task) is close to PP's session
    management

* 18. Cursor AI

** What it does
AI-first code editor (VS Code fork). Multi-model, agent mode, tab completion,
MCP support. The most popular AI IDE.

** Architecture
- Model: proprietary (cursor-small) + OpenAI, Anthropic, Gemini
- Tools: agent mode, tab completion, chat, @-symbols, MCP, terminal
- Memory: session; no cross-session persistence
- Safety: diff view, configurable permission levels, image input support

** Differentiators
- First-mover in AI IDEs (fork vs extension approach)
- .cursorrules for project conventions
- Fast tab completion (custom small model)
- @-symbol context system (files, docs, web)

** Maturity
Production. Most popular AI IDE.

** Relevance to Passepartout: LOW
--- IDE-dependent. PP is philosophy of terminal + .org + Emacs
--- No neurosymbolic, no persistent memory, no contract-first

* 19. Augment Code

** What it does
AI coding platform with deep codebase understanding. Agent, chat, CLI (Auggie),
context engine that indexes entire codebase.

** Architecture
- Model: proprietary + multi-model
- Tools: agent, code completions (sunset soon), CLI (Auggie), IDE extensions
- Memory: codebase index (persistent), session context
- Safety: enterprise SSO, permissions

** Differentiators
- Auggie CLI — terminal-first agent (closest to PP)
- Codebase-wide context engine (indexes entire repo, not just open files)
- Agent can tackle large tasks autonomously

** Maturity
Production. Well-funded.

** Relevance to Passepartout: HIGH
--- Auggie CLI is directly comparable: terminal-native coding agent
--- Full codebase indexing is better than PP's current approach
--- No neurosymbolic. No contract-first. No org-mode source-of-truth.
--- PP's TDD + contract + tangle workflow is unique differentiator

* 20. Qoder

** What it does
Coding agent platform. Details limited.

** Architecture
Unknown — website unreachable.

** Maturity
Unknown.

** Relevance to Passepartout: UNKNOWN
--- Insufficient data.

* 21. v0 by Vercel

** What it does
UI generation agent. Generates React/Next.js components and pages from text
prompts. Visual design oriented.

** Architecture
- Model: proprietary (likely fine-tuned)
- Tools: code generation, visual design mode, templates, deployment to Vercel
- Memory: per-session; design context within chat
- Safety: Vercel platform controls

** Differentiators
- Visual-first: generates UI, not general code
- Design mode: fine-tune with visual controls
- Template library
- iOS app for mobile building
- Deep Vercel/Next.js integration

** Maturity
Production.

** Relevance to Passepartout: LOW
--- Narrow domain (UI generation). Not a general coding agent.
--- Cloud-only. No TUI.
--- No relevance to PP's workflow.

* 22. Lovable

** What it does
Full-stack application generation from natural language prompts. Build and
deploy apps/websites via AI chat.

** Architecture
- Model: proprietary (likely fine-tuned)
- Tools: app generation, deployment, domain registration, mobile app
- Memory: per-project conversation
- Safety: platform-level moderation

** Differentiators
- Full-stack: frontend + backend + DB + deploy
- No-code-friendly (describe app → get working app)
- Template library, mobile companion app
- Enterprise security claims

** Maturity
Production.

** Relevance to Passepartout: LOW
--- Consumer/no-code focus. Not a developer coding agent.
--- No TUI, no extensibility, no memory persistence beyond project.

* 23. Void (formerly based on Codex)

** What it does
CLI coding agent for terminal-based AI code generation. Originally built on
OpenAI Codex.

** Architecture
- Model: OpenAI API-compatible
- Tools: terminal code generation, file writing
- Memory: session context
- Safety: user approval on file changes

** Differentiators
- CLI-native (similar to Codex CLI)
- Lightweight

** Maturity
Beta/early.

** Relevance to Passepartout: MEDIUM
--- CLI-native coding agent, directly comparable to PP
--- Less mature than Codex CLI or Aider
--- No unique differentiators

* 24. Cosine Genie

** What it does
Autonomous AI software engineer. Takes Jira tickets or PR descriptions, breaks
them down, writes code, delivers PRs. Works asynchronously.

** Architecture
- Model: Genie 2 (proprietary model); 72% on SWE-Lancer
- Tools: IDE/CLI, Slack, Jira, Linear, GitHub integration
- Memory: task-level context; works asynchronously in background
- Safety: sandboxed; desktop app runs locally; cloud service

** Differentiators
- Proprietary model (Genie 2) — not just wrapping an API
- SWE-Lancer leader: 72% pass rate (highest)
- Asynchronous: works without active session
- Slack/Jira/Linear integration for task intake
- CLI + Desktop app + Cloud

** Maturity
Production. Well-funded.

** Relevance to Passepartout: HIGH
--- Direct competitor: agent that takes tickets and delivers code
--- CLI-native operation
--- No contract-first, no neurosymbolic, no org-mode
--- PP's structured TDD cycle + deterministic rules are key differentiators
--- Cosine's Slack/Jira integration interesting for PP to consider

* 25. Mentat

** What it does
CLI coding assistant that coordinates edits across multiple files. Project
context understanding.

** Architecture
- Model: any LLM (OpenAI, Anthropic)
- Tools: file editing across multiple files, project context gathering
- Memory: session context, git awareness
- Safety: user approval

** Differentiators
- Multi-file editing focus
- Project-level understanding

** Maturity
Currently inactive/archived. GitHub 404.

** Relevance to Passepartout: LOW
--- Inactive project. No meaningful differentiation from Aider/Codex CLI.

* 26. Ghostwriter by Replit (→ see Replit Agent #12)
* 27. Poolside

** What it does
Foundation models for software engineering. Builds models + agents for
enterprise. On-prem deployment, air-gapped. TUI, IDE extensions, agents.

** Architecture
- Model: Laguna XS.2 M.1 (proprietary foundation model)
- Tools: agents, TUI, IDE extensions, multi-agent orchestration
- Memory: enterprise context (connectors to repos, DBs, private data)
- Safety: on-prem/VPC/air-gapped, RBAC for humans and agents, audit trails,
  executive governance, no data leaves customer boundary

** Differentiators
- Full-stack: builds foundation models + agents + enterprise deployment
- Forward Deployed Research Engineers embedded with customers
- Outcome ownership (not just model handoff)
- AGI thesis: software engineering as path to AGI
- Military/defense-grade security (not just compliance)

** Maturity
Production. Frontier lab status. $500M+ funding.

** Relevance to Passepartout: LOW
--- Enterprise/military focus, completely different market
--- Building own models (PP uses existing LLMs)
--- TUI is just one surface among many
--- PP's individual-developer, open-source, TDD-first philosophy is opposite

* 28. Tabnine

** What it does
Enterprise AI code completion + agent platform. Code completions, chat, agents,
CLI, context engine. Gartner Visionary 2025.

** Architecture
- Model: multiple (code-specific small models + large model access)
- Tools: code completion, chat, CLI, agents (planning, coding, testing, docs),
  context engine, provenance/attribution
- Memory: Enterprise Context Engine (indexes org codebase, architecture,
  standards)
- Safety: on-prem/air-gapped/VPC, zero data retention, IP indemnity,
  provenance tracking, admin controls, audit logs

** Differentiators
- Enterprise Context Engine: organizational intelligence layer for any agent
- Fine-tuning on private repos
- Provenance & attribution for IP compliance
- Gartner Visionary; Leader in Omdia Universe
- Zero Trust compliance (air-gapped)

** Maturity
Production. 15+ years in market (originally Codota). Millions of developers.

** Relevance to Passepartout: LOW
--- Enterprise-focused (compliance, IP, governance). PP is individual-agent.
--- Context Engine concept is interesting but proprietary
--- No neurosymbolic. No contract-first.
--- CLI is secondary to IDE completions for Tabnine

* 29. Factory Droid (→ see #6)
* 30. Devin (→ see #5)

* Emerging / Notable Others

** Conductor (Melty) — see #16
** Cline — see #7
** RooCode — see #8
** Augment Code CLI (Auggie) — see #19
** Cosine Genie — see #24

* Cross-Cutting Analysis

** Safety / Security Architecture

| System | Sandbox | Human-in-Loop | Diff Review | Gov/Enterprise | Notes |
|--------|---------|---------------|-------------|----------------|-------|
| Aider  | Git undo| File approval  | Git diff    | No             | Git as safety net |
| Cline  | None    | Every op      | Diff view   | SSO, on-prem   | Best HIL in class |
| Codex CLI | Sandboxed exec | On write/command | Console output | No | Basic |
| Devin  | Sandboxed env | Deployment gate | PR review | Enterprise plan | Cloud sandbox |
| Cursor | None    | Configurable   | Diff view   | No             | .cursorrules |
| Copilot| None    | Configurable   | Diff view   | SSO, audit, MCP allowlist | Best enterprise |
| Cosine | None    | PR review      | PR review   | Cloud + on-prem| Async operation |
| Tabnine| None    | Configurable   | Diff view   | Air-gapped, on-prem, audit | Best air-gapped |
| Poolside| Deploy boundary | Enterprise governance | Platform | Air-gapped, defense | Most secure by design |

** Memory Persistence

Nearly ALL systems have session-only memory. Exceptions:
- Tabnine: Enterprise Context Engine (persistent codebase index)
- Devin/Windsurf: Spaces (bundled context across sessions)
- Poolside: enterprise connectors to repos+DBs
- AutoGPT: vector DB persistent memory

Passepartout's approach: git + .org files as source of truth is unique and
powerful — no other system uses literate programming as memory.

** TUI / CLI Interface

CLI-native systems: Aider, Codex CLI, Cosine Genie, Void, Augment CLI
IDE-first: Cursor, Windsurf, Copilot, Cline, Continue, PearAI
Both: GitHub Copilot CLI, Poolside TUI

PP is CLI + Emacs. Closest in philosophy: Aider, Codex CLI, Cosine Genie.

** Extensibility Model

- MCP (Model Context Protocol): Cline, Cursor, Windsurf, Copilot, AutoGen
- Custom prompts/rules: .cursorrules, .clinerules, AGENTS.md, CLAUDE.md
- Python scripting: Aider
- Agent creation: AutoGPT (block builder), CrewAI (role-based)
- MCP server creation: Cline ("add a tool" via LLM)

PP's extensibility: Common Lisp macros + skill system. Unique: hot-reloadable
skills, self-repair capability. No other system has this.

** Neurosymbolic / Deterministic Rule Components

NONE of the surveyed systems have a neurosymbolic architecture or deterministic
rule engine. The closest approximations:
- .cursorrules / .clinerules / AGENTS.md / CLAUDE.md: plain-text instructions
  to the LLM (zero enforcement)
- Cline's MCP tools: deterministic tool execution but no rule reasoning
- Tabnine's Provenance: deterministic code matching but not rules
- AutoGen's event-driven core: deterministic workflow but not rule-based
  reasoning

Passepartout's contract-first TDD (machine-verifiable contracts + Fiveam tests)
is architecturally unique. No competitor has anything like it.

* Key Takeaways for Passepartout

1. NO competitor has neurosymbolic architecture or deterministic rule
   enforcement. This is PP's strongest differentiator.

2. NO competitor uses literate programming (.org as source of truth) or
   org-babel tangle workflow. This is PP's second strongest differentiator.

3. NO competitor has hot-reloadable, self-repairable skills. PP's skill system
   (Lisp macros + fboundp guards) is unique.

4. Memory persistence is universally weak. PP's git + .org approach is
   arguably more robust than any competitor's session-only model.

5. CLI-native agent space is growing: Codex CLI, Aider, Cosine Genie, Auggie.
   PP must match or exceed their terminal UX quality.

6. MCP is becoming the universal extensibility standard. PP should support MCP.

7. Async/background operation (Cosine Genie, Devin) is a growing expectation.
   PP's REPL-based daemon architecture is well-positioned for this.

8. Enterprise features (SSO, on-prem, audit) are table stakes for enterprise
   but irrelevant for PP's individual-agent use case.

9. Multi-agent orchestration (AutoGen, CrewAI, Conductor) is a separate
   concern. PP should focus on single-agent excellence first.

10. The "contract-first TDD" workflow from .org → write test → watch fail →
    implement → watch pass → tangle is UNIQUE in the entire competitive
    landscape.
