amr/memex
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects 1 Releases Wiki Activity
Files
18b289dff8c8004251fef8bbb4451a807b23bd04
memex/COMPETITIVE_ANALYSIS.org
Amr Gharbeia 4e9431ec1d memex: update passepartout submodule → v0.7.2, add notes 
passepartout v0.7.2 (Gate Trace + HITL + Search + 11 more features):
- Gate trace visualization with Ctrl+G toggle
- HITL inline panels with styled collapse on approve/deny
- Agent identity file + /identity command
- Safe-tool read-only allowlist
- Message search mode with Up/Down nav and highlights
- Context budget visibility with section breakdown
- Session rewind /sessions /resume /rewind
- Undo/redo per operation
- Context debugging /context why /context dropped
- Tool hardening (timeouts, write verify, read-only cache)
- Tag stack severity tiers + trigger counts
- Merkle provenance audit + audit-verify
- Self-help /help <topic> reads USER_MANUAL.org
- Live CONFIG section in system prompts
- Pads: Page Up/Down scroll by 10 lines

Core 92/92  TUI Main 104/104  TUI View 29/29  Neuro 13/13
2026-05-08 21:56:11 -04:00

29 KiB
Raw Blame History

Competitive Analysis — AI Coding Agents & Personal AI Agent Systems

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.
Reference in New Issue View Git Blame Copy Permalink