The framework gives you skills, context templates, and a full automation layer — cron, webhooks, Slack, CLI. But the part that evaluates every event, scores confidence, decides whether to auto-execute or queue for approval, and graduates actions to autonomous over three sprint cycles — that's the intelligence layer. It's the part you can't build from a repo.
The open source framework gives you the skills. The automation layer makes them run on a schedule. But there are two gaps most teams can't close alone: the behavioral one (finishing all 8 context files) and the technical one (building the intelligence layer). We close both.
Your architecture decisions, why you chose that database, which services are fragile, who owns what, what "ready for review" actually means on your team. The framework gives you context file templates — we make sure they actually get filled, across four sessions instead of one, with the follow-up questions you'd skip.
We encode that knowledge into the 8 context files from the framework: system architecture, team topology, ADRs, review playbook, definition of done, capacity model, and learnings. Same templates, but filled completely — the part most teams skip after the first file.
The framework's 6 skills, configured against your real context. Spec generation that knows your ADRs. Risk detection that knows your critical paths. Review routing that knows who owns which services and who's overloaded. Same skills from the open source repo, but tuned to your data.
The automation layer fires skills on hardcoded triggers. The intelligence layer evaluates every event — reads the PR diff, checks which services are touched, scores confidence — and decides whether to auto-execute or queue for your approval. Over three sprint cycles, low-risk actions graduate to autonomous. By week 8, the system handles 60–70% of actions without you. This is the layer that's never in a repo.
You cloned the framework. You filled in system-architecture.md and the output was great. Then you got busy and the other seven files never happened. Guided Setup is us sitting across from you for two 90-minute sessions and making sure you don't stop. By week 3, you have all 8 context files complete, 4 skills tuned to your real data, and output you trust without editing.
For engineering teams of 5-15 working in 1-3 repos.
Two 90-minute sessions with your EM or tech lead. We walk through your architecture, team structure, sprint process, review standards, and what's burned you recently. We ask the follow-up questions Claude won't -- the ones that surface why you chose Postgres over Mongo three years ago, which engineer quietly owns three services, and what "ready for review" actually means when it's 4pm on a Friday. This is the work most people skip when they try it solo.
We produce your 8 structured context files from the interview data: product strategy, system architecture map, ADRs, team topology, spec template, review playbook, definition of done, and learnings. Then we configure Skills 1–4 (Spec Generator, Ticket Decomposer, Risk Detector, Review Orchestrator) against your context.
We generate 3 real specs from your backlog, decompose them into tickets, and run a risk scan on your current sprint, all using your context. You review the output against your own standards. We refine until the quality matches what you'd produce yourself. Then we hand off the system with documentation.
You run the system through one full sprint. We're available for async support: adjusting context files, tuning risk thresholds, fixing skill output quality. By the end of this week, the system produces output you trust without editing.
Your engineering judgment encoded as structured markdown: architecture, team, standards, learnings. The agent reads these before every run.
Spec Generator, Ticket Decomposer, Risk Detector, and Review Orchestrator, each tuned to your team's real data.
The system instructions file that teaches Claude Code how to use your context and skills. Drop it in any repo.
Local database tracking specs, tickets, risk signals, and review assignments. Zero external dependencies.
GitHub client configured for your repos. Linear or Jira client mapped to your project structure.
Async Slack/email support through your first sprint. We adjust context files and thresholds based on real output.
The framework and automation layer are free. Guided Setup closes the persistence gap — complete context, tuned skills, output you trust. Full Implementation builds the intelligence layer — the router that evaluates events, scores confidence, and graduates to autonomous over three sprints.
Everything in Guided Setup, plus the intelligence layer you can't build from the repos. The automation layer handles cron and webhooks — we add the router that evaluates every event, scores confidence, and decides whether to auto-execute or queue for approval. Over three real sprint cycles, low-risk actions graduate to autonomous. The system runs continuously. You approve only what matters.
Four 90-minute sessions covering multiple teams, cross-team dependencies, shared services architecture, and organizational workflow patterns. We map team topologies, service ownership boundaries, and the real escalation paths your org uses (not the ones on the wiki).
All 6 skills configured (adding Release Manager and Retro Analyzer). GitHub webhook handlers installed on your repos. Linear/Jira integration with bidirectional sync. Slack bot deployed to your workspace for digests, alerts, and approval flows.
The agent brain goes live. Events from GitHub, Linear, and cron schedules flow through the router. The router evaluates each event, selects the right skill, scores confidence, and determines whether to auto-execute or queue for your approval. Everything starts at approval-required.
Sprint 1: You approve everything, building trust and training the system. Sprint 2: Low-risk actions (PR summaries, digests, informational labels) graduate to autonomous. Sprint 3: Review routing and status updates graduate if approval history supports it. By week 8, the system handles 60–70% of actions without you.
Full skill suite including Release Manager and Retro Analyzer. The retro skill feeds learnings back into context files every sprint.
GitHub webhooks, Linear webhooks, and cron-scheduled scans flow through a normalized event queue. The agent runs continuously, not on-demand.
The agent brain: evaluates events, selects skills, scores confidence, and routes to auto-execute or approval queue. Human-editable routing rules.
Morning risk digests, weekly sprint summaries, approval request flows, and direct alerts for blocked work, all posted to your channels automatically.
Four-tier autonomy system from always-autonomous (digests) to always-requires-approval (ticket creation). Thresholds calibrated to your risk tolerance.
Active support through three sprint cycles. We adjust routing rules, confidence thresholds, and autonomy levels based on real approval data.
| Framework (free) | Guided Setup | Full Implementation | |
|---|---|---|---|
| Context files | Templates | Filled (2 sessions) | Filled (4 sessions) |
| Skills 1–4 (Spec, Tickets, Risk, Review) | Definitions | Configured + tuned | Configured + tuned |
| Skills 5–6 (Release, Retro) | Definitions | - | Configured + tuned |
| agentem doctor | ✓ | ✓ | ✓ |
| Cron + webhooks | - | - | ✓ |
| Slack integration | - | - | Digests + approvals |
| Intelligent router | - | - | ✓ |
| Confidence scoring | - | - | ✓ |
| Approval model | - | - | 4-tier autonomy |
| Tuning support | - | 1 sprint | 3 sprints |
| How it runs | Manual prompting | Manual prompting | Event-driven |
| Multi-team support | - | Single team | Cross-team |