Autonomous agents, production-ready

The framework for running
Claude agents at work

007 is a self-contained Docker environment that runs Claude Code as an autonomous agent — clones a repo, receives a role, plans and ships changes, then hands off via the medium native to the domain.

See how it works Browse roles
$ just run engineer/software-developer

One container.
One role. One outcome.

Each run is stateless. The agent reads from the world, does its work, and writes back through the natural medium — no coordination layer needed.

📦
01
Container starts
The container sets up git, credentials, and installs the latest agent resources. Clean slate every time.
📝
02
Role is loaded
Shared guardrails load first, then role-specific agents and skills are merged into the agent's configuration.
🔗
03
Prompt pulled at runtime
The role prompt is fetched at runtime from a managed prompt registry — edit prompts centrally and promote through staging → production.
🤖
04
Claude works autonomously
Up to 100 turns. Claude reads its inputs from the world — a tracked issue, a record, a codebase — and executes the role using all available skills and tools.
📋
05
Progress logged in real time
Every step is written to a structured log file, mounted back to the host. Tail it live with tail -f logs/agent.log.
🔄
06
Hands off via the right medium
A PR is opened, an issue comment is posted, or a record is updated. The next agent picks up exactly where this one left off.

Every run is observable

Structured timestamped log lines. See exactly what the agent did, when, and whether it succeeded — while it's still running.

logs/engineer-software-developer-a3f2.log
2026-06-18T09:00:01Z done start Role loaded, starting work on assigned issue
2026-06-18T09:00:18Z done clone Cloned target repository (main)
2026-06-18T09:01:04Z done read-issue Parsed issue requirements and acceptance criteria
2026-06-18T09:02:31Z done find-target Located the relevant module and entry point
2026-06-18T09:04:55Z done write-fix Implemented fix and added unit tests
2026-06-18T09:05:10Z done verify All tests pass (0 failures)
2026-06-18T09:05:33Z done finish Pull request opened — ready for review

One agent per job

Roles cluster by domain. Each gets its own prompt, guardrails, and skills. Trigger from the command line, a chat message, or an event on the queue.

# Trigger from the command line just engineer ISSUE-123 just investigate ISSUE-456 just run tax/monthly-closing # Or via chat !engineer/software-developer ISSUE_ID=ISSUE-123
# task.json — single source of truth { "role": "engineer/software-developer", "context": { "source": "chat", "triggered_at": "2026-06-18T09:00:00Z", "trace_id": "4bf92f35-77b3" }, "task_payload": { "ISSUE_ID": "ISSUE-123" } }
engineer
software-developer
Implements code changes, writes tests, and opens pull requests against a tracked issue.
PR → Git
engineer
investigate-issue
Reads code and logs to find the root cause of a tracked issue and reports back.
Comment → Issue
engineer
data-engineer
Answers data questions and runs reports against a database. Saves reusable queries via PR.
Query → PR
finance
revops-assistant
Revenue and sales reporting across CRM and billing systems for RevOps and finance teams.
Report → Chat
finance
billing-investigator
Previews what will be invoiced for all orgs, or traces sold/signed/delivered/billed for root-cause.
Analysis → Chat
tax
monthly-closing
Runs the monthly closing workflow for an organization, writing draft bookings via API.
Record → API
ops
hello-world
Smoke-test role that verifies infrastructure, credentials, and tool access are all working.
Log → stdout
ops
evaluator
Evaluates conversation quality and posts structured feedback scores to the ops pipeline.
Score → Chat

The medium is the
coordination layer

No extra orchestration needed. Agents hand off through whatever is native to the domain — a second agent reads the current state and picks up from there.

Domain: Code
GitHub PR branch + comments
Reviewer requests changes on the PR; writer amends and pushes a new commit.
Domain: Product
Issue description + comments
Clarifier adds acceptance criteria to the issue; engineer implements from there.
Domain: Accounting
Domain API records
Booking agent writes a draft record; reviewer agent corrects and re-submits.

Event-driven, container-per-task

Runs are triggered by events on a message queue. A listener dispatches each event to a task launcher, which starts a fresh container — one agent per task.

Event queue
──▶
Listener
long-running service
──▶
Task launcher
on-demand
──▶
Agent container
ephemeral
a permissions policy controls which roles the listener will dispatch  ·  each task gets its own ephemeral container
🔒
Non-root container
Runs as an unprivileged user inside a fully ephemeral, isolated container. Nothing persists between runs.
🧱
Hard guardrails
Shared guardrails enforce: no direct pushes to main, no force-push, no destructive SQL, no secret logging. Cannot be overridden by role prompts.
📡
Run tracing
Every run creates a trace posted at start and updated on finish. Only operational metadata — role, tag, turn count, status. No customer data.
🛠
Shared + role-specific skills
Shared skills (messaging, issue tracking, logging) bake into the container image. Role-specific skills mount at runtime — no rebuild needed to ship new capabilities.
☁️
EU-hosted models
Claude runs via a managed model provider hosted in the EU — data stays in the EU. Credentials are injected from a secrets manager at task start.
🔁
Multi-agent loops
Writer → reviewer → writer. The outer loop stops when the reviewer approves. Each agent reads the current state of the medium — no extra coordination code.