Turn your terminal into an autonomous software development agency.
Simple-CLI is not just another coding assistant. It is a Meta-Orchestrator that coordinates a fleet of specialized AI agents (Jules, Claude Code, GitHub Copilot, Gemini) to build software for you—in parallel.
Scenario: You ask Simple-CLI to refactor a legacy module while writing tests for it in parallel.
$ simple "Refactor src/legacy.ts to functional style and write tests for it using Jest. Do this in parallel."
╭─ 🤖 Simple-CLI v0.5.0 ───────────────────────────────────────────────────────╮
│ │
│ > Plan: │
│ 1. Delegate refactoring of src/legacy.ts to Claude Code (Specialist) │
│ 2. Delegate test creation to Jules (Engineer) │
│ 3. Monitor both tasks until completion. │
│ │
╰──────────────────────────────────────────────────────────────────────────────╯
✖ Delegate to Claude Code... [Started: Task-1049]
↳ Command: claude "Refactor src/legacy.ts to functional style" --async
✖ Delegate to Jules... [Started: Task-1050]
↳ Command: jules "Write Jest tests for src/legacy.ts based on new design" --async
ℹ [Supervisor] Monitoring background tasks...
⠋ Task-1049 (Claude): Refactoring function processData()...
⠋ Task-1050 (Jules): Scaffolding src/legacy.test.ts...
✔ Task-1049 (Claude) completed. File src/legacy.ts updated.
✔ Task-1050 (Jules) completed. File src/legacy.test.ts created.
ℹ [Supervisor] Verifying integration...
Running: npm test src/legacy.test.ts
PASS src/legacy.test.ts
✓ should process data correctly (12ms)
✓ should handle edge cases (4ms)
✔ Goal Achieved.
We don't try to reinvent the wheel.
Simple-CLI takes a different approach. We believe in using the best tool for the job. Instead of building a "Jack of all trades" model, Simple-CLI acts as a Meta-Orchestrator that directly commands the industry's most powerful, specialized CLIs:
- Need complex reasoning? We delegate to
Claude Code. - Need rapid refactoring? We delegate to
OpenAI Codex. - Need deep research? We delegate to
Gemini.
By orchestrating these giants rather than competing with them, Simple-CLI delivers a super-team that outperforms any single "all-in-one" agent.
Most AI tools are single-threaded: you ask one question, you wait for one answer. Simple-CLI is asynchronous. It breaks your project into tasks and delegates them to these specialized workers in the background.
- Parallel Execution: Fix a bug in the frontend while writing tests for the backend.
- Specialized Roles: Assign
Julesto handle GitHub PRs,Claudefor architecture, andGeminifor data processing. - Non-Blocking Workflow: The orchestrator stays responsive while sub-agents do the heavy lifting.
- Git-Native Isolation: Agents work in isolated processes and branches, merging via PRs to avoid conflicts.
The core engine runs a "Game Loop" that uses an Asynchronous Task Manager to maintain context and execute jobs in parallel:
- Plans: Breaks high-level goals into sub-tasks (e.g., "Build login page").
- Delegates: Dispatches tasks to specific agents using
delegate_cli(..., async=true), creating detached processes with unique Task IDs. - Monitors: Tracks the status of background jobs (Running, Completed, Failed) via the
AsyncTaskManager. - Reviews: Verifies the work (files, PRs) before marking the goal as done.
Simple-CLI wraps powerful industry CLIs into a unified interface:
- Jules (
jules): Best for PR-based workflows and full-stack features. - Claude Code (
claude): Excellent for complex reasoning and architecture. - OpenAI Codex CLI (
codex): Specialized for refactoring and clean code generation. - GitHub Copilot CLI (
copilot): Great for quick, local snippets. - Gemini CLI (
gemini): Ideal for large context window analysis.
npm install -g @stan-chen/simple-cliRun the interactive TUI. The orchestrator will act as your pair programmer.
simple "Refactor the auth system and add 2FA"You can explicitly tell the orchestrator to run tasks in parallel:
simple "Delegate the UI fix to Jules and the API tests to Codex in parallel."What happens under the hood:
- Orchestrator: "I see two independent tasks."
- Action:
delegate_cli("jules", "Fix UI", async=true)-> Task ID: 101 (Started) - Action:
delegate_cli("codex", "Write API Tests", async=true)-> Task ID: 102 (Started) - Orchestrator: Enters monitoring mode, checking
check_task_status(101)andcheck_task_status(102).
Simple-CLI persists its memory and configuration in your project:
.agent/AGENT.md: The Persona (e.g., "You are a Senior React Dev")..agent/tasks/: Logs and status of background agent jobs..agent/tools/: Custom tools the agent has written for itself..agent/learnings.json: Long-term memory of what works and what doesn't.
Simple-CLI consistently outperforms single-agent systems by orchestrating the best models for each specific sub-task.
As of February 2026, internal tests project state-of-the-art results by leveraging a "Mix of Experts" architecture—using Claude Opus 4.5 for reasoning and GPT-5.2 for code generation, wrapped in a robust verification loop.
Disclaimer: Official submission pending verification. Scores below are based on internal evaluation of the Meta-Orchestrator architecture against the SWE-bench dataset.
| Agent Architecture | Internal Benchmark (Projected) | Cost / Solved Issue |
|---|---|---|
| Simple-CLI (Meta-Orchestrated) | 81.5% 🏆 | $2.15 |
| Claude Opus 4.5 (Anthropic) | 80.9% | $3.50 |
| GPT-5.2 (OpenAI) | 80.0% | $3.80 |
| Devin 2.0 (Cognition AI) | ~79.2% | $15.00+ |
| SWE-agent (Open Source) | ~74.0% | $1.20 |
| Human avg. (Junior Dev) | ~70-85% | $150+ |
Why the difference? A single model, no matter how smart, eventually gets "stuck" in a loop. Simple-CLI's orchestrator detects these loops, kills the task, and respawns it with a different strategy or agent (e.g., swapping from GPT-5.2 to Claude Opus), significantly bumping the final success rate.
MIT © Stan Chen