outpost

Point Claude Code at a task and a set of tools — it does the rest.

outpost is a small, general agent runtime: you wake it on demand with a goal, it dispatches a headless Claude Code agent that uses your tools to actually get the job done — search the web, hit APIs, run commands, connect to integrations — streams what it does live, and checks the result against a quality bar.

It's not just for coding. Claude Code is a general worker, not only a pair-programmer. Point outpost at any goal-directed task — plan a trip, run a job search, triage a repo, automate a recurring chore — by dropping in a capability. The agent learns the job from a short skill file; there's no per-task orchestration code and no scripted procedure.

The trip-generation POC this grew out of proved the core: Claude Code, run headless, is a capable task runtime if you give it the right environment — a goal, the right tools, and a bar to clear. outpost is that environment, made domain-agnostic and triggerable.

Heavily inspired by paperclip.ai — its control-plane model (dispatch tasks to agents, watch an event stream, keep humans in the loop, govern the run) is the lineage here. outpost is a small, self-hostable take on that idea built on Claude Code.

---

How it works

flowchart LR
    IN["task input<br/>(INPUT.md)"] --> RT
    CAP["capability<br/>skill · tools · quality bar"] --> RT
    RT["outpost runtime"] -->|"spawns headless"| CC(("Claude Code<br/>agent"))
    CC <-->|"real tools<br/>web · files · shell"| WORLD["the world"]
    CC -->|"stream-json events"| RT
    CC -->|"writes"| ART["artifact<br/>(shortlist.json …)"]
    ART --> QB{"quality bar"}
    QB -->|pass| DONE["✅ done"]
    QB -->|miss| ESC["escalate model,<br/>run once more"]
    ESC --> CC

Loading

The agent's decisions are its own — how to search, what to trust, how to rank. The skill file teaches the contract and the tools, never the procedure. Tool calls hit the real world.

A capability is just a folder

No code to add a new one — drop a folder in capabilities/:

capabilities/job-hunt/
├── capability.yaml     # allowed tools, model, budget, artifact, quality bar
└── SKILL.md            # teaches the agent its task + output contract

# capability.yaml
name: job-hunt
allowed_tools: [Bash, Read, Write, WebSearch, WebFetch]
model: sonnet
max_budget_usd: 2.0
artifact: shortlist.json
quality_bar: { artifact_exists: true, min_items: 3 }

Ships with three real-tool capabilities (no mocks)

Capability	What it does	Tools it connects
job-hunt	Given a candidate profile, searches the real web and produces a ranked shortlist of currently-open roles with a fit rationale for each.	web
trip-planner	Given a destination and constraints, researches real logistics and builds a day-by-day itinerary grounded in sources it actually fetched.	web
repo-triage	Given a GitHub issue, investigates the real codebase via the gh CLI and writes an actionable, file-level fix plan.	GitHub (gh)

Connect your own tools. A capability can declare an MCP config (mcp_config: mcp.json) to wire in integrations — Slack, GitHub, a database, an internal API — or just use the shell to drive any CLI. The agent then acts, not just reports.

Run it

pip install -e .
outpost list
outpost run job-hunt   --input examples/criteria.md
outpost run trip-planner --input examples/trip.md

You'll see the agent's reasoning and tool calls stream live; the artifact lands in runs/<session>/. Requires the claude CLI on your PATH and web tools enabled.

Or trigger it on demand (HTTP)

The CLI is for you; the service is for everything else — a webhook, a cron job, a Slack command, or another agent can wake a capability and watch it run.

pip install -e '.[serve]'
outpost serve                       # POST /run/{cap}, GET /events/{session} (SSE)

sequenceDiagram
    participant T as trigger<br/>(webhook · cron · Slack · you)
    participant O as outpost
    participant CC as Claude Code agent
    T->>O: POST /run/job-hunt {input}
    O-->>T: { session_id }
    O->>CC: wake a session (goal + tools)
    T->>O: GET /events/{session}  (SSE)
    loop live
        CC-->>O: reasoning + tool calls
        O-->>T: streamed events
    end
    CC->>O: artifact written
    O->>O: quality-gate (escalate if needed)
    O-->>T: spawn.exit

Loading

On-demand awakening, a watchable stream, a goal, real tools, a graded result.

Read more

• Claude Code is a task runtime — not just a pair programmer — the thinking behind outpost.

Design notes

• Trimmed preamble. The agent spawns without user settings or MCP servers — a clean, cheap context scoped to the task (spawner.py).
• Quality bar + escalation. A cheap model runs first; if the artifact misses the bar, outpost escalates to a stronger model once (runtime.py). The bar is the only non-trivial logic and it's unit-tested.
• Evidence, not vibes. Capabilities ask the agent to write a ledger.md of non-obvious calls alongside the artifact, so a run is auditable.

---

By Ruben Tugnolo. Inspired by paperclip.ai.