sudocode

sudocode is a lightweight agent orchestration system that lives in your repo. Adding sudocode into your repo adds instant organizational capabilities to your coding agents. They'll gain the ability to track context over long-horizon tasks and work collaboratively on complex tasks.

Key capabilities

• Automate context handoff for complex tasks with sudocode's git-native agent memory system
• Bring order to chaos by organizing your requirements, background context, and implementation plans into structured, executable issue graphs
• Visualize outputs and execution feedback in real-time
• Run as many Claude Code/Codex/Cursor (+more) agents in parallel as you can handle

How it works

sudocode tracks human-specified requirements and objectives (what to do) as specs, and agent runtime context and plans (how to implement) as issues. These are trackable in git as a form of version-controlled memory for your agents. Specs/issues are both human and agent-editable. This allows agents to manage their own context and leave contextual breadcrumbs as they run for all agents to reference.

Specs and issues form the backbone for advanced agent coordination and automation. Use specs to define high-level requirements and let agents carry out the implementation and manage their own issues.

How to use it

The sudocode package includes a CLI, local server/UI, and an MCP server.

Use the CLI for managing specs and issues in sudocode's agent memory system. It contains a complete interface for viewing, editing, and managing relationships between entities.

Use the local server to automatically sync memory and enable agent execution and visualization. The issue kanban view helps you track issue status and progress. You can spawn new agents, update agent implementation plans, and provide feedback or guidance to running agents in a single, focused view.

The spec editor view boosts spec-driven development to new heights. Edit and review specs with a full-featured block or markdown editor. Agents leave feedback on specs as they execute, so you can track their work and stay in the know for with the code they produce.

Once you have a dependency graph of issues, you can also automate the implementation of each issue in the graph as a workflow. This runs each issue in topological order and accumulates changes in a temp branch/worktree. As it's executing, each issue will have its own commit, so you can revert backwards in the commit history if you want to continue developing from a specific point.

If you're up for it, you can even monitor all running agent trajectories at the same time.

sudocode provides a structured yet flexible system for organizing the chaos of human-AI collaboration in software development.

Quick Start

# Install globally (recommended: use npx instead to avoid Node version conflicts)
npm install -g sudocode

# Initialize a sudocode project in your project directory.
sudocode init

# Run the local sudocode server from anywhere
sudocode server

# To connect your agent directly to sudocode, install our plugin
claude plugin marketplace add sudocode-ai/sudocode
claude plugin install sudocode
# Note, instructions for other agents can be found in the quick start guide

Check out our Quick Start Guide for tutorials and walkthroughs.

External Integrations

sudocode now supports syncing with external spec and issue tracking systems through a plugin-based integration framework. This allows you to maintain specs and issues in your preferred tools while keeping sudocode's agent memory system in sync.

Supported Integrations:

In the sudocode UI, enable integrations in Settings > Integrations. Via the CLI, update with sudocode plugin.

Integrations automatically create specs, issues, and relationships between synced entities and support real-time file watching for immediate sync updates. Use sudocode to link and implement work items across different systems.

We're actively adding support for new integration targets. Please file an issue or drop a message for anything you would like sudocode to support!

Context-as-Code

Your context and designs are just as valuable as the code being written. Code is often over-specified, while your actual requirements are under-specified and come with design choices and intent that is not immediately captured.

With sudocode, you treat your git repo as a distributed context database to capture context and make it readily available to coding agents. You can track user intent (specs), agent tasks (issues), and agent trajectories (executions) as they evolve alongside your codebase.

• Distributed Collaboration: Human developers and AI agents share one logical database across multiple environments through git synchronization
• Lightweight: All your context lives under your control in your repo
• Integrated Audit Trail: Context can be recovered with git's immutable change tracking
• Agent Persistence: Reduce agent hallucinations and amnesia by keeping task context in version-controlled files instead of ephemeral conversations

Git handles distribution while AI handles merge conflicts.

Spec-Driven Development

A spec can be thought of as user intent + relevant context. Combined, a spec contains enough information for an agent to carry out the requirements defined in the task.

• Structured Context: Create connections between your specs with a rich graph structure, and organize context dynamically so it is easily discoverable by agents
• Advanced Organization: Create structured task dependencies to keep track of blocking issues and hidden relationships between tasks
• Iterative Refinement: Move through multiple refinement stages as agents provide bi-directional feedback as they implement on your specs

Reduce the chaos of "vibe coding" by establishing clear, executable requirements in order to produce predictable outcomes.

Context Structure

sudocode implements a 4-tiered abstraction structure for representing context, corresponding to increasing granularity from high-level requirements to low-level implementation:

1. Spec (Specification)

A primitive for user intent and context—requirements, RFCs, research questions, design decisions. Specs capture WHAT you want.

• Organized as nodes in a graph structure
• Support hierarchical relationships and cross-cutting links
• Stored as human-editable Markdown with YAML frontmatter
• Live in .sudocode/specs/

2. Issue

A primitive for agent intent and context—work items derived from specs, capturing tasks within agent scope.

• Link back to specific requirements in specs via [[@ISSUE-001]] references
• Support hierarchical organization, dependencies, and relationships
• Graph relationship types: blocks, related, parent-child, discovered-from
• Stored as Markdown + JSONL (.sudocode/issues/)

3. Agent

The execution abstraction—represents the actual trajectory of an agentic loop run against an issue.

• Tracks agent system (Claude Code, Codex, etc.) and configurations
• One-to-many relationship with issues (supports multiple execution sessions per issue)
• Captures sub/multi-agent structures and unique workflows
• Configuration stored in .sudocode/agents/

4. Artifact

A primitive representing state changes from agent execution.

• e.g. Code diffs for coding agents, reports for research agents, documentation updates for docs agents
• Multiple artifacts per execution

Key Features

Dual Issue/Spec Representation

Every entity has both a **hum