Skip to content
/
Tier A A6 Multi-agent orchestrator

your-claude-engineer (coleam00)

coleam00-your-claude-engineer · coleam00/your-claude-engineer · ★ 850 · last commit 2025-06-01

Autonomous software factory that takes a plain-text app spec and delivers a running web app with Linear issues tracked, GitHub PRs created, and Slack notifications sent — enforcing a screenshot evidence gate before any feature is marked complete.

Best whenExternal SaaS tools (Linear, GitHub, Slack) are the proper memory and state store for long-running agent sessions — not local files or databases. A single OA…
Skip ifMarking an issue Done without screenshot evidence, Starting new feature work before verifying existing features pass
vs seeds
superpowersis a C…
Primitive shape 4 total
Subagents 4
00

Summary

coleam00/your-claude-engineer — Summary

your-claude-engineer is a Python-based multi-agent harness by coleam00 that demonstrates a complete software engineering workflow with explicit third-party integrations: Linear (project management), GitHub (version control + PRs), Slack (notifications), and browser testing via Playwright MCP. Built on the Anthropic Claude Agent SDK (Python), it uses a hierarchical orchestrator + 4 specialized subagents (linear, coding, github, slack) coordinated via the Claude Task tool. Each agent has its own dedicated model selection (haiku/sonnet/opus via environment variables) and its own prompt file in prompts/. All external service integrations are powered by the Arcade MCP server providing OAuth across Linear, GitHub, and Slack through a single gateway. The orchestrator enforces two mandatory quality gates: a screenshot evidence gate (no issue marked Done without browser screenshot evidence) and a verification gate (coding agent must verify existing features pass before starting new work). This is the most complete "software factory" demonstration in this batch — one python autonomous_agent_demo.py command produces a running web app with Linear issues tracked, GitHub branches/PRs created, and Slack notifications sent.

differs_from_seeds: your-claude-engineer is closest to superpowers in that it enforces specific workflow gates (verification gate, screenshot evidence gate) and uses subagent-driven development. However, superpowers is a Claude Code plugin with CLAUDE.md-injected behavioral rules; your-claude-engineer is a standalone Python script using the Claude Agent SDK. The Slack/GitHub/Linear integration trinity, the per-agent model selection, and the Arcade MCP gateway as a single OAuth source for all external services are absent from all 11 seeds.

01

Overview

coleam00/your-claude-engineer — Overview

Origin

Authored by coleam00 on GitHub. The README describes it as:

"A demonstration of an agent harness with access to tools like Slack, GitHub, and Linear so it can act as your own complete software engineer."

It uses the Anthropic Claude Agent SDK (Python) and is described as building on "the Anthropic Harness for long running tasks."

Philosophy

From the README:

"Ever wished you could hand off a feature request and have it come back fully implemented, tested, and documented? Your Claude Engineer is a harness built on top of the Anthropic Harness for long running tasks and using the Claude Agent SDK that turns Claude into a long-running software engineer capable of tackling complex, multi-step tasks that go far beyond a single prompt."

"The multi-agent architecture uses specialized agents (Linear, Coding, GitHub, Slack) coordinated by an orchestrator, enabling longer autonomous sessions without context window exhaustion."

"All external service integrations are powered by the Arcade MCP server, providing seamless OAuth authentication across Linear, GitHub, and Slack through a single gateway."

Two Mandatory Gates (from orchestrator_prompt.md)

  1. Verification Gate (MANDATORY before any new feature work):

    • Ask coding agent to run verification test
    • Wait for PASS/FAIL
    • If FAIL: fix regressions first; do NOT proceed
    • "This gate prevents broken code from accumulating."

  2. Screenshot Evidence Gate (MANDATORY before marking any issue Done):

    • Coding agent must provide screenshot_evidence paths
    • If no screenshots: Reject and ask for evidence
    • "No screenshot = No Done status."

Key Constraints

  • WSL/Linux only: Does not work on Windows due to Claude Agent SDK limitations
  • Arcade MCP required: All GitHub/Slack/Linear access via Arcade gateway (OAuth)
  • Project type: Web application (includes init.sh for dev server, Playwright for browser testing)
02

Architecture

coleam00/your-claude-engineer — Architecture

Distribution

  • Type: Python script (clone-and-configure)
  • License: MIT
  • Runtime: Python 3.10+ (virtual environment recommended)
  • Platform: Linux/macOS (WSL on Windows)

Dependencies

  • anthropic-claude-code (Claude Code CLI, npm)
  • claude-agent-sdk (Python)
  • Arcade MCP gateway (cloud service)
  • Playwright (browser testing via Playwright MCP)

Directory Structure

your-claude-engineer/
├── autonomous_agent_demo.py  # Entry point — orchestrator loop
├── agent.py                  # Agent base class + Claude Agent SDK integration
├── client.py                 # Anthropic client setup
├── prompts.py                # Prompt loading utilities
├── agents/
│   ├── __init__.py
│   ├── definitions.py        # Agent tool definitions (passed to orchestrator)
│   └── orchestrator.py       # Orchestrator agent implementation
├── prompts/
│   ├── orchestrator_prompt.md     # Orchestrator behavior + 2 mandatory gates
│   ├── coding_agent_prompt.md     # Coding agent instructions + Playwright usage
│   ├── linear_agent_prompt.md     # Linear project management instructions
│   ├── github_agent_prompt.md     # Git + PR creation instructions
│   ├── slack_agent_prompt.md      # Slack notification instructions
│   ├── initializer_task.md        # First-run task template
│   ├── continuation_task.md       # Continuing work template
│   ├── app_spec.txt               # App specification (filled by user)
│   └── example_app_specs/         # Example specs
├── arcade_config.py               # Arcade MCP gateway config
├── authorize_arcade.py            # OAuth authorization helper
├── security.py                    # Security utilities
└── .claude/                       # Claude Code settings (if any)

Multi-Agent Architecture

ORCHESTRATOR (haiku)
├── linear agent (haiku)     → Linear issues, status, META tracking
├── coding agent (sonnet)    → Write code, Playwright testing, screenshots
├── github agent (haiku)     → Git commits, branches, PRs
└── slack agent (haiku)      → Progress notifications

Config via Environment Variables

Variable Default Description
ARCADE_API_KEY required Arcade API key
ARCADE_GATEWAY_SLUG required MCP gateway slug
ARCADE_USER_ID recommended Email for user tracking
ORCHESTRATOR_MODEL haiku Orchestrator model
CODING_AGENT_MODEL sonnet Coding agent model
GITHUB_AGENT_MODEL haiku GitHub agent model
SLACK_AGENT_MODEL haiku Slack agent model
LINEAR_AGENT_MODEL haiku Linear agent model
GITHUB_REPO optional Auto-push if set
SLACK_CHANNEL optional Slack channel name
03

Components

coleam00/your-claude-engineer — Components

Entry Point: autonomous_agent_demo.py

CLI arguments:

  • --project-dir — target project directory
  • --generations-base — base path for generated project output
  • --max-iterations — maximum orchestrator loop iterations
  • --model — override default model

Responsibilities: initialize the agent loop, load task templates (initializer vs continuation), pass the app spec from prompts/app_spec.txt into the first task, and drive the orchestrator until completion or iteration limit.

Agent Base Class: agent.py

Wraps the Claude Agent SDK Task invocation. Each subagent call creates a new Task with:

  • A system prompt loaded from the corresponding prompts/*.md file
  • A list of tools (MCP tools from Arcade gateway + Playwright)
  • A user message constructed by the orchestrator

Orchestrator Agent: agents/orchestrator.py

Stateful component driving the outer loop. Uses claude-haiku by default. Core logic:

  1. Reads prompts/orchestrator_prompt.md as system prompt
  2. Maintains conversation history across iterations
  3. Dispatches sub-tasks to specialized agents via the Claude Task tool
  4. Enforces the two mandatory gates (Verification Gate, Screenshot Evidence Gate)
  5. Tracks Linear issue status — no Done transition without screenshot paths

Tool Definitions: agents/definitions.py

Defines the tool schemas passed to the orchestrator for invoking each subagent. Each tool corresponds to one of the four specialized agents (linear, coding, github, slack). The orchestrator calls these as Claude tools; the SDK routes them to the appropriate agent.py subagent instance.

Prompt Files (prompts/)

File Purpose
orchestrator_prompt.md Orchestrator behavior, gate enforcement, issue lifecycle
coding_agent_prompt.md Code writing, Playwright usage, screenshot evidence
linear_agent_prompt.md Linear issue creation, status updates, META tracking
github_agent_prompt.md Git commits, branch management, PR creation
slack_agent_prompt.md Progress notifications to Slack channel
initializer_task.md First-run task template referencing app_spec.txt
continuation_task.md Continuation template for interrupted sessions
app_spec.txt User-supplied application specification

Arcade MCP Gateway: arcade_config.py + authorize_arcade.py

arcade_config.py — builds the MCP server connection config pointing at the Arcade gateway endpoint using ARCADE_API_KEY + ARCADE_GATEWAY_SLUG.

authorize_arcade.py — interactive OAuth authorization helper for first-time setup. Walks the user through authorizing Linear, GitHub, and Slack access via Arcade's OAuth flow.

Claude Code CLI (.claude/)

The coding agent runs claude-code CLI commands (npm-installed) for file operations, shell execution, and browser testing. Playwright testing is accessible via the mcp__playwright__* tool suite provided through Claude Code's MCP integration.

Security: security.py

Utility module for environment variable validation and sensitive-value masking in logs. Prevents accidental credential exposure in console output.

Project Output Structure

Generated projects are placed under GENERATIONS_BASE_PATH/<project-name>/:

<project-name>/
├── init.sh        # Dev server startup (created by coding agent)
├── <source>       # Generated application code
└── screenshots/   # Playwright screenshot evidence
05

Prompts

coleam00/your-claude-engineer — Prompts

Prompt Architecture

All agent system prompts live in prompts/ as Markdown files. They are loaded at runtime by prompts.py and injected as the system parameter for each Claude Task invocation. No prompts are hard-coded in Python source.

orchestrator_prompt.md

The most important prompt. Contains:

  • Role definition: "You are an expert software engineering orchestrator"
  • Issue lifecycle management instructions (Linear integration)
  • Verification Gate block (mandatory, verbatim):
### Verification Gate (MANDATORY)
Before ANY new feature work:
1. Ask coding agent to run verification test
2. Wait for PASS/FAIL response
3. If FAIL: Fix regressions first (do NOT proceed to new work)
4. If PASS: Proceed to implementation
This gate prevents broken code from accumulating.
  • Screenshot Evidence Gate block (mandatory, verbatim):
### Screenshot Evidence Gate (MANDATORY)
Before marking ANY issue Done:
1. Verify coding agent provided screenshot_evidence paths
2. If no screenshots: Reject and ask coding agent to provide evidence
No screenshot = No Done status.
  • Agent dispatch instructions: which agent to call for which task category
  • Tool usage: when to use linear_agent, coding_agent, github_agent, slack_agent

coding_agent_prompt.md

Instructs the coding agent (claude-sonnet) on:

  • File read/write conventions via Claude Code tools
  • When and how to use mcp__playwright__* tools
  • Screenshot capture pattern: mcp__playwright__screenshot → return paths as screenshot_evidence
  • Verification test: run npm test or python -m pytest and return PASS/FAIL
  • Init script: expect init.sh in project root to start dev server
  • Browser testing workflow: navigate → interact → screenshot → assert

linear_agent_prompt.md

  • Linear project creation and issue management via Arcade MCP tools
  • Status transition rules: Backlog → In Progress → Done
  • META issue tracking: top-level planning issue kept in sync
  • Arcade tool names: arcade__linear__*

github_agent_prompt.md

  • Branch naming convention: feature/<linear-issue-slug>
  • Commit message format
  • PR creation with Linear issue reference in description
  • Arcade tool names: arcade__github__*

slack_agent_prompt.md

  • Notification format: project name + issue completed + PR link
  • When to notify: after each issue Done transition
  • Channel target: $SLACK_CHANNEL env var
  • Arcade tool names: arcade__slack__*

Task Templates

initializer_task.md

Template for the first run. Placeholder {{APP_SPEC}} is filled with the contents of app_spec.txt at runtime. Instructs the orchestrator to:

  1. Create a Linear project from the spec
  2. Break the spec into individual Linear issues
  3. Begin with project scaffolding

continuation_task.md

Template for resumed sessions. Instructs the orchestrator to:

  1. Read Linear for current issue status
  2. Find first issue not in Done
  3. Resume from there

app_spec.txt

User-supplied plain-text application specification. No required format — can be free prose, bullet list, or structured spec. The content is injected into initializer_task.md and becomes the source of truth for all Linear issues created.

example_app_specs/

Directory of sample specifications showing expected format:

  • One file per example app type
  • Demonstrates level of detail expected (features, tech stack, acceptance criteria)
09

Uniqueness

coleam00/your-claude-engineer — Uniqueness

differs_from_seeds

your-claude-engineer is closest to superpowers in that it enforces specific workflow gates (verification gate, screenshot evidence gate) and drives development via subagent-based task execution. However, the comparison breaks down quickly:

  • superpowers is a Claude Code plugin whose gates are enforced via CLAUDE.md-injected behavioral rules; your-claude-engineer is a standalone Python script using the Claude Agent SDK directly
  • superpowers has no external service integrations; your-claude-engineer has a trinity of Linear + GitHub + Slack all wired via a single OAuth gateway
  • No seed has per-agent model selection (haiku for management, sonnet for coding)
  • No seed uses an external MCP gateway (Arcade) for OAuth across three SaaS platforms simultaneously
  • No seed externalizes all durable state to Linear (issues as checkpoint store, screenshot paths in issue comments)

The Linear-as-checkpoint pattern is unique in the corpus: session continuity is provided by reading Linear issue status rather than any local file or database.

Most Distinctive Features

  1. Arcade MCP Gateway — single OAuth source for Linear, GitHub, and Slack; avoids per-service credential management
  2. Linear as checkpoint store — no local state files; continuation_task.md resumes by querying Linear for incomplete issues
  3. Screenshot Evidence Gate — "No screenshot = No Done status" is enforced in the orchestrator prompt and is the only hard acceptance criterion for feature completion
  4. Per-agent model selection — the coding agent runs on Sonnet while all management agents run on Haiku, reducing cost without sacrificing coding quality
  5. app_spec.txt → Linear issues pipeline — plain-text app spec is automatically decomposed into tracked Linear issues at session start

Observable Failure Modes

  • Prompt-only gate enforcement: Both gates are in the orchestrator's system prompt, not in hard code. If the orchestrator LLM skips a gate (possible with haiku), no exception is raised
  • WSL-only on Windows: Claude Agent SDK limitation; breaks the demo for Windows users outside WSL2
  • Arcade dependency: Requires paid Arcade account and active MCP gateway; not self-hostable without replacing the Arcade layer
  • No context compaction: Long-running sessions accumulate orchestrator history in-process; very long sessions may degrade quality or hit context limits
  • Sequential subagent execution: No parallelism; each agent blocks the orchestrator; slow for large feature sets
  • Linear coupling: If Linear is unavailable or the API quota is exceeded, the entire workflow halts

Comparison with Other Batch-29 Frameworks

Aspect your-claude-engineer thClaws MateClaw Utah/Inngest
Runtime Python script Rust binary JVM daemon Node.js serverless
State persistence Linear (cloud) Local filesystem DB + LESSONS.md Inngest steps
Gate enforcement Prompt-based N/A N/A N/A
External integrations Linear+GitHub+Slack None 8 IM channels None
Auth mechanism Arcade OAuth gateway N/A Per-channel config N/A
Multi-model Yes (per-agent) No Yes (14+ providers) No
04

Workflow

coleam00/your-claude-engineer — Workflow

Setup Phase

  1. Clone repository
  2. Create Python virtual environment; install dependencies (claude-agent-sdk, etc.)
  3. Install claude-code CLI via npm
  4. Set environment variables: ARCADE_API_KEY, ARCADE_GATEWAY_SLUG, ARCADE_USER_ID
  5. Run python authorize_arcade.py — OAuth authorization for Linear, GitHub, Slack
  6. Edit prompts/app_spec.txt — paste your application specification
  7. Optionally set GITHUB_REPO and SLACK_CHANNEL env vars

Execution Phase

python autonomous_agent_demo.py [--project-dir <dir>] [--max-iterations N]

Iteration 0: Initializer Task

Orchestrator receives initializer_task.md filled with app_spec.txt content. First actions:

  1. Linear agent — creates Linear project with issues for each app feature
  2. Coding agent — scaffolds project, runs init.sh, verifies dev server starts

Main Loop (repeated per Linear issue)

for each Linear issue not Done:
  1. [VERIFICATION GATE] — Orchestrator calls coding agent to run verification test
     - PASS: proceed
     - FAIL: fix regressions, re-run gate before any new work

  2. Orchestrator plans implementation approach

  3. Coding agent:
     a. Reads existing code (Claude Code file tools)
     b. Implements the feature
     c. Runs Playwright tests via mcp__playwright__*
     d. Captures screenshot evidence (screenshot paths returned in result)

  4. [SCREENSHOT EVIDENCE GATE] — Orchestrator checks for screenshot_evidence paths
     - No screenshots: reject, send back for evidence
     - Screenshots present: proceed

  5. GitHub agent:
     a. git checkout -b feature/<slug>
     b. git commit + push
     c. Create PR

  6. Linear agent — marks issue Done

  7. Slack agent — sends notification to SLACK_CHANNEL (if configured)

Continuation Mode

If the session is interrupted and re-run, continuation_task.md is used instead of initializer_task.md. The orchestrator reads Linear to find incomplete issues and resumes from the last unfinished issue.

Gate Logic Detail

Verification Gate (from orchestrator_prompt.md):

"This gate prevents broken code from accumulating."

  • Triggered before every new feature implementation
  • Coding agent runs a test suite or smoke test against the existing codebase
  • PASS = all existing tests green; FAIL = regressions must be fixed first

Screenshot Evidence Gate (from orchestrator_prompt.md):

"No screenshot = No Done status."

  • Triggered before the orchestrator approves any Linear issue Done transition
  • screenshot_evidence must be a non-empty list of file paths
  • Paths point to Playwright screenshots captured during the coding agent's test run

Completion

The loop ends when either:

  • All Linear issues are in Done status
  • --max-iterations is reached (partial progress preserved in Linear)

Final state: web app running locally, all features in Linear Done, GitHub PRs created, Slack channel notified.

06

Memory Context

coleam00/your-claude-engineer — Memory & Context

Context Strategy

your-claude-engineer uses a hierarchical context model where:

  • The orchestrator maintains a running conversation history across iterations
  • Each subagent invocation is a fresh context (new Claude Task), receiving only the specific task message
  • No global shared memory store; state is externalized to Linear

Orchestrator Conversation History

The orchestrator's history accumulates across the main loop iterations, building a running record of:

  • Which Linear issues have been processed
  • Which agents were dispatched and their outcomes
  • Screenshot evidence paths received
  • Gate results (PASS/FAIL)

This in-process Python list serves as the working memory. It is not persisted to disk — if the process exits, this history is lost and a new run starts from continuation_task.md.

External State: Linear as Persistent Memory

Linear issues serve as the durable state store. Each issue tracks:

  • Feature name and description (from app spec)
  • Current status: Backlog / In Progress / Done
  • Comments with implementation notes and screenshot paths

This means the orchestrator can resume after interruption by reading Linear state, without needing to store anything locally.

Subagent Context Isolation

Each subagent call (linear_agent, coding_agent, github_agent, slack_agent) is a separate Claude Agent SDK Task. Subagents receive only:

  • Their specific system prompt (prompts/<agent>_prompt.md)
  • The task message constructed by the orchestrator

Subagents have no access to the orchestrator's conversation history or other subagents' outputs. This prevents context pollution and keeps each agent's context window clean.

App Spec: prompts/app_spec.txt

The primary long-term specification document. Written once before the run and injected into the orchestrator's first task. Not updated during execution. Serves as the immutable source of truth.

Session Continuity

Continuation mechanism:

  1. User re-runs autonomous_agent_demo.py (same project dir)
  2. continuation_task.md template is used
  3. Orchestrator queries Linear for incomplete issues
  4. Resumes from first non-Done issue

No session file, no checkpoint file — Linear is the checkpoint.

Screenshot Evidence Paths

Screenshot paths returned by the coding agent are stored in the orchestrator's conversation history as part of the task result. They are also referenced in Linear issue comments (via linear_agent). This provides a dual record: in-process (history) and durable (Linear comment).

Context Window Management

The orchestrator runs on claude-haiku which has a large context window. No explicit truncation logic is present; the design relies on:

  • Subagent isolation keeping per-task contexts small
  • Linear externalizing the cross-iteration state
  • Haiku's ability to process long conversation histories efficiently

If context grows too large in a single session, the --max-iterations limit caps accumulation.

07

Orchestration

coleam00/your-claude-engineer — Orchestration

Pattern: Hierarchical Orchestrator + Tool-Dispatched Subagents

autonomous_agent_demo.py (main loop)
  └── Orchestrator Task (haiku)
        ├── linear_agent tool  → Linear Task (haiku)
        ├── coding_agent tool  → Coding Task (sonnet)
        ├── github_agent tool  → GitHub Task (haiku)
        └── slack_agent tool   → Slack Task (haiku)

The orchestrator is a Claude Task that receives a set of tool definitions corresponding to the four subagents. When the orchestrator calls coding_agent(task="implement login"), the Claude Agent SDK intercepts the tool call and spawns a new Task for the coding agent. The result is returned as the tool call's output.

Orchestration Mechanism: Claude Agent SDK Task Tool

The Task tool is the Claude Agent SDK primitive for agent-to-agent delegation. It provides:

  • Fresh context per subagent invocation
  • Structured result return (JSON-compatible)
  • Blocking (synchronous from orchestrator's perspective)

All subagent invocations are sequential — the orchestrator waits for each subagent to complete before proceeding. No parallel agent execution.

Model Assignment

Agent Default Model Override Env Var
Orchestrator claude-3-haiku ORCHESTRATOR_MODEL
Linear agent claude-3-haiku LINEAR_AGENT_MODEL
Coding agent claude-3-sonnet CODING_AGENT_MODEL
GitHub agent claude-3-haiku GITHUB_AGENT_MODEL
Slack agent claude-3-haiku SLACK_AGENT_MODEL

Haiku for all management/communication tasks; Sonnet for the coding agent which requires stronger reasoning.

Gate Enforcement in Orchestration

Both mandatory gates are enforced by the orchestrator's prompt, not by code. The orchestrator:

  1. Verification Gate: Calls coding_agent with a "run verification test" task; inspects the result for PASS/FAIL; refuses to proceed if FAIL
  2. Screenshot Evidence Gate: Inspects the coding_agent result for screenshot_evidence field; refuses to call linear_agent with Done status if absent

This means gate enforcement relies on the orchestrator LLM following its prompt instructions. No hard code enforcement.

Arcade MCP Gateway Integration

All external service tools are injected into each subagent via the Arcade MCP gateway connection configured in arcade_config.py. The MCP server exposes:

  • arcade__linear__* tools — Linear API operations
  • arcade__github__* tools — GitHub API operations
  • arcade__slack__* tools — Slack messaging operations

The orchestrator does not call these tools directly — it delegates to the appropriate specialized agent which has those tools in scope.

Playwright MCP Integration

The coding agent has access to mcp__playwright__* tools via Claude Code's MCP integration. The orchestrator prompt instructs it to:

  • Use mcp__playwright__navigate to open the dev server
  • Use mcp__playwright__screenshot to capture evidence
  • Return screenshot file paths in the screenshot_evidence result field

Loop Termination

The main Python loop (autonomous_agent_demo.py) terminates when:

  1. The orchestrator reports all Linear issues Done, OR
  2. --max-iterations is reached

The orchestrator itself runs indefinitely within a single iteration; iteration count is tracked in Python, not in the prompt.

08

Ui Cli Surface

coleam00/your-claude-engineer — UI & CLI Surface

CLI: autonomous_agent_demo.py

Single Python script entry point. No dedicated CLI package — invoked directly via python autonomous_agent_demo.py.

python autonomous_agent_demo.py [OPTIONS]

Options:
  --project-dir PATH        Target project working directory
  --generations-base PATH   Base directory for generated project output
  --max-iterations N        Maximum orchestrator loop iterations (default: unlimited)
  --model MODEL             Override all agent model selections

Setup CLI: authorize_arcade.py

Interactive OAuth authorization helper. Run once before first use:

python authorize_arcade.py

Walks through OAuth consent flows for:

  • Linear
  • GitHub
  • Slack

Stores tokens in Arcade gateway (not locally).

No Web UI

There is no local web dashboard or browser-based interface. All interaction is:

  1. Pre-run: Edit prompts/app_spec.txt
  2. Runtime: Terminal output from the orchestrator loop
  3. External: Linear web app (issue tracking), GitHub (PRs), Slack (notifications)

Terminal Output

The Python script prints the orchestrator's reasoning and subagent invocations to stdout. No structured log format — raw Claude Task output is streamed.

Claude Code CLI Integration

The coding agent uses claude-code (npm package) as a subprocess tool. The coding agent itself does not expose a new CLI; it uses Claude Code's file manipulation and shell execution tools internally via MCP.

Environment Variable Configuration

Primary configuration interface:

# Required
export ARCADE_API_KEY=<key>
export ARCADE_GATEWAY_SLUG=<slug>

# Recommended
export ARCADE_USER_ID=<email>

# Optional integrations
export GITHUB_REPO=<owner/repo>      # enables auto-push
export SLACK_CHANNEL=<channel-name>  # enables notifications

# Model overrides
export ORCHESTRATOR_MODEL=claude-3-haiku-20240307
export CODING_AGENT_MODEL=claude-3-5-sonnet-20241022
export GITHUB_AGENT_MODEL=claude-3-haiku-20240307
export SLACK_AGENT_MODEL=claude-3-haiku-20240307
export LINEAR_AGENT_MODEL=claude-3-haiku-20240307

Platform Constraints

  • macOS / Linux only — The Claude Agent SDK does not support native Windows
  • WSL2 required on Windows — Must run in WSL2 environment if on Windows
  • Python 3.10+ virtual environment strongly recommended to avoid dependency conflicts

External UI Surfaces (not bundled)

Surface Purpose
Linear web app View issues, track progress, see screenshot evidence in comments
GitHub Review PRs created by github_agent
Slack Receive progress notifications from slack_agent

These are standard SaaS apps — your-claude-engineer writes to them but does not host any UI of its own.

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k
A6 Multi-agent orchestrator

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k
A6 Multi-agent orchestrator

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k
A6 Multi-agent orchestrator

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k
A6 Multi-agent orchestrator

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k
A6 Multi-agent orchestrator

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k
A6 Multi-agent orchestrator

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…