Example Workflows
Choose one example, see the shared backbone, or jump to the trace library before reading the full route.
Pick the lane, then the page
Atlas stays easier to scan when the route map reads like navigation first. Start with the lane that matches your question, then expand the full page-job model only when you need the deeper contract details.
Execution-story page for how real work usually unfolds from intake to visible closeout.
Change pace: Usually current for a while, but revisit when routes, ownership, or workflows shift.
If a workflow raises ownership or structure questions, jump back to the route that owns that layer.
Open Projects & ChartersEntry
Use these pages when you are still orienting and need the safest first click before you pick an owner or system.
Ownership
Use these pages when your real question is who should handle the work, how it moves, or which charter owns the surface.
Systems
Use these pages when you need the map, structure, services, and interfaces behind the network instead of the people or routing rules.
Operations
Use these pages when something feels broken, you need a concrete next check, or you need the live-status companion surface.
Workflow spine
Now viewing Choose a trace
Choose one example by the question you brought
Show me the cleanest end-to-end story
Start with the shared request backbone, then open the PR Review trace. That pair teaches the standard intake → route → execute → verify → closeout pattern faster than reading the whole library in order.
First-time readers who want the default workflow shape before learning special cases.
Stop after the backbone and PR Review once you can explain who receives the request, who owns the work, and how the result comes back.
One representative path, end to end
- 1.Jake sends "review PR #234" via WhatsApp. Clawdy's gateway (port 18789) receives it.
- 2.Clawdy classifies: GitHub task → Currybot specializes here. Decision takes ~200ms.
- 3.Clawdy bridges to Currybot (port 18791) with task metadata. Bridge emits a
request_sentevent into the OpenObserve-backed telemetry stream. - 4.Currybot runs
gh pr view 234andgh pr diff 234, queries Recall for context, and analyzes the changes (~2.8 s). - 5.Results flow back through Bridge to Clawdy, who formats them for WhatsApp. Total round-trip: ~4 seconds.
- 6.Jake gets a scannable summary — code quality, test status, one concrete suggestion. Neither Clawdy nor Jake saw the raw tool output.
Full animated trace → Workflow 1 below.
A person, cron job, or upstream system starts the workflow with a concrete request.
The first agent decides: do it here, ask for guidance, or delegate to a better specialist.
The specialist runs the work — code, search, policy review, design audit, or sync task.
Before closing out, the system checks output quality, applies gates, or records the result.
A human-readable update goes back to the caller or channel so the work is actually usable.
Three ways the same request backbone can split
The fastest way to understand network workflows is to compare similar requests that diverge for different reasons. The intake and closeout pattern stays familiar; what changes is whether the work stays local, asks for specialist judgment, or pauses for governance before execution continues.
“Improve the Atlas docs so a new teammate can follow how work moves.”
- •Scout receives the request inside the Atlas charter cycle on branch scout/how-work-moves-walkthrough.
- •The bounded gate checks current registry and Orchestrator evidence; when an advisor pass is available it adds context, otherwise Scout closes it with local workspace evidence.
- •Scout opens the feature branch, delegates code changes to Codex (codex exec --model codex-mini-latest), and commits the result.
- •Verification runs: bun run typecheck && bun run lint pass. PR #18 opens on scout/how-work-moves-walkthrough.
- •Scout rewrites the charter scratchpad, syncs out, and posts a Scout-authored Atlas Linear Project Update. Slack appears only if that closeout cannot land.
Why it branches: Scout already owns this charter and has exec + git access. Routing out would add latency without adding capability.
“This new page renders correctly — does it match the design system?”
- •Scout pushes the new content to PR #18 and screenshots the rendered output at http://main-mini:18797/workflows.
- •Screenshot + “does this match the design system?” routes to Meg via Bridge (Clawdy → bridge.ts → Meg, port 18800).
- •Meg returns a punch list: adjust card spacing, darken slate-700 backgrounds, confirm Tailwind v4 class names used.
- •Scout applies the punch list, verifies on the dev server, and merges. Watchtower logs the Meg advisory event.
Why it branches: Visual judgment is Meg's lane, not Scout's — and the Bridge call costs ~1 second vs. multiple wrong-guess iterations.
“Can we add a new public-facing route to the Atlas site?”
- •Scout proposes adding a new top-level route (/how-it-works) to the Atlas site based on user feedback.
- •Atticus receives the proposal via Bridge: “New public route /how-it-works — is this in scope for the next public release?”
- •Atticus checks Anvil policy: new routes require a content-readiness gate. Returns ruling ATT-2026-04-0041: approved with condition — page must pass the public-safe audit before deploy.
- •Scout resumes implementation under ruling ATT-2026-04-0041. Grafton records the conditional approval in the lifecycle ledger.
Why it branches: Public surface changes carry policy risk. Atticus decouples the permission decision from the implementation so the work doesn't have to restart if the answer is no.
The work queue accelerates cycles; crons remain the floor
Every charter cycle starts by pulling its lane on the Saffron Orchestrator work queue (port 18830, detailed on the Infrastructure page). Items in a lane are work someone deliberately routed to that agent — an Arbor request can land as a queue item — and the cycle works them first. The pull is capped at two or three items per cycle, then regular charter work resumes, so the queue can never starve the charters it serves.
The queue is fail-soft by design: if it is unreachable, the pull reads as an empty lane and the cycle proceeds normally. Scheduled cron cycles — not queue events — are what carry the network, and throughput today is near zero by design, which is what a healthy floor-plus-accelerator looks like. Lane rosters and host operations stay in the operator-side design doc; the map explains the mechanism, not the current roster.
Why some agents ship products and others maintain process
No shipped artifact — maintains, reviews, synthesizes, or governs.
- CrucibleStewardship
Clawdy's workspace analyst — surfaces friction and process improvements from real session patterns
Family workspace-improvement
Cadence cron, daily workspace-friction observation
- Saffron FoundryStewardship
Clawdy's weekly network intelligence brief — who did what, what changed, where friction showed up, and what opportunities emerged
Family network-intelligence
Cadence cron, weekly Sunday network-intelligence brief
- AlmanacStewardship
Atticus's knowledge synthesizer — reviews sessions and agent state 2x/day, extracts what's worth the whole network knowing, publishes and refreshes shared docs in Notion Saffron Docs, and relies on rag-sync to expose them through the saffron-docs QMD collection
Family knowledge-synthesis
Cadence cron, twice daily shared-doc refresh
- AnthologyStewardship
The Founders OS charter: mines Jake's and Derek's real work (reviews, refactors, meetings, decisions) into the source-backed anthology QMD collection — jake/derek lenses plus synthesis — through a self-regulating pipeline (corroboration + True/Useful/Safe refuter, no approval gate). Consumers: Coach, Currybot pr-review, builders at shaping moments.
Family knowledge-synthesis
- CompassStewardship
Atticus's network health charter — learns Jake's expectations for how the Saffron network should operate, then surfaces alignment, friction, consistency gaps, and opportunities
Family governance-alignment
Cadence cron, weekly governance/alignment review plus manual review
- LedgerStewardship
Atticus's meeting notes pipeline — Fellow recordings → structured Notion notes via webhook trigger
Family record-pipeline
Cadence webhook from Fellow with 15-minute poll fallback
- CoachStewardship
Atticus's per-teammate growth coach over Slack DM — check-in prep, pattern reflection, and ask-anything, grounded in each person's own check-in history via per-person QMD collections in the coaching index
Family evaluation
Cadence reactive — Slack DM routed by per-user bindings (pilot: Antony)
- Grafton's ShearsStewardship
Grafton's correctness lens — reviews Linear Projects for state drift, misalignment, and stale claims
Family hygiene-drift
Cadence cron, every six hours for structural-truth and drift review
- TrellisStewardship
Grafton's forward-motion lens — keeps charter pipelines healthy by sharpening goals and proposing well-shaped next moves when actionable work runs thin
Family flow-management
Cadence cron, recurring flow/routing/backlog health review
- Watering BucketStewardship
Grafton's support lens — improves handoff quality and surfaces stuck work across charter Linear Projects
Family readiness-context
Cadence cron, twice-daily readiness scan plus focused drill-down
- RakeVerification
Grafton's meta lens — gathers patterns from cycle-quality reports, fixes bounded issues, surfaces structural recommendations
Family evaluation
Cadence cron, daily recent-cycle batch review plus weekly synthesis
- LoupeDiscovery
Meg's close-inspection lens — catches UX, composition, and accessibility drift in Saffron projects before it compounds. Findings are advisory by default, with milestone-tied Blocking findings and explicit Loupe re-check/sign-off for Blocking and Important follow-up items. Shallow reviews at Scout cycle-close; deep comb-through rotates through projects on a 4–6 week cadence.
Family design-review
Cadence hybrid: artifact-triggered, milestone-gated, and twice-daily cadence safety net
- LanternAlignmentRetired
Retired Samwise intake charter. Its reusable judgment now lives in the parent samwise-intake skill; retained for historical evidence.
Family delivery-intake
Cadence retired; no independent cycles
- Barq Client PilotStewardshipPaused
Daily digest and project tracking for the Barq client engagement
Family client-support
Cadence process cycle for client-support digest and tracking
Ships code or a visible artifact — builds something readers can use or see.
- AnvilDiscovery
Scout's AI rules engine — analyzes, mines, and codifies rules that are small, sharp, and grounded in real failure modes
Family product-build
Cadence project charter cycle, Linear-first task intake
- AtlasDiscovery
Scout's network cartographer — produces animated workflow diagrams of the Saffron agent network
Family product-build
Cadence project charter cycle, Linear-first task intake
- ForgeDiscovery
Scout's Forge charter — researches and builds new Saffron/OpenClaw capability, including workspace-generation and scaffolding lines
Family product-build
Cadence project charter cycle, Linear-first task intake
- WatchtowerShipping
Observability dashboard — monitors infrastructure events via local SQLite collector.
Family product-build
Cadence project charter cycle, Linear-first task intake
- Podcast PlatformAlignment
Scout's podcast platform — creator-first hosting and distribution app proving the Saffron Starter stack on a real content product
Family product-build
Cadence project charter cycle, Linear-first task intake
- Saffron StarterShipping
PDLP-driven component library and app starter — design tokens, Storybook, visual verification
Family design-engineering-build
Cadence cron, twice-daily design-engineering starter work
- LC Classic StarterShipping
Form-first component library and starter kit — recipes, patterns, and primitives for LC projects
Family design-engineering-build
Cadence cron, daily design-engineering starter work
- SpadeShippingRetired
Retired Samwise execution charter. Its reusable delivery and project-orientation behavior now lives in parent skills; retained for historical evidence.
Family delivery-execution
Cadence retired; no independent cycles
- Forge (retired Grafton alias)StewardshipRetired
Retired Grafton-side alias for Scout's active Forge line — preserved so older openclaw-forge references still resolve, but it has no independent Project Update target
Family lifecycle-management
Cadence retired alias only; no independent charter cycles
If you are asking this question, open this trace first
I need a fast example of a normal request moving through the network
Start with the PR review trace if you want the cleanest intake → routing → specialist → response example.
Best first stop for “show me the backbone.”
I want to see how Atlas or Scout work gets shipped autonomously
Start with the Scout cycle if your question is about freshness gates, charter loops, and a real docs delivery path.
Best first stop for “what does a real charter cycle look like?”
I need an example where work gets routed to another specialist
Start with Cross-Agent Delegation to see when the first agent hands off instead of doing the work locally.
Best first stop for “who keeps this and who hands it off?”
I need to understand where policy or approval interrupts delivery
Start with Governance Check to see the pause-for-ruling pattern before execution continues.
Best first stop for “can the network do this, or does it need a ruling?”
I want a concrete design review handoff
Start with Design Review (Meg) to see how visual judgment and implementation loop together.
Best first stop for “when does Meg step in?”
I am here because something broke and I want the escalation path
Start with Watchtower — Alert Escalation for the clearest failure → throttle → notify sequence.
Best first stop for “what happens when a service fails?”
I want to see how product ideas become experiments in Labs
Start with the Dexter + Buzz Labs Experiment Lifecycle to see the full arc: idea → experiment design → distribution → honest assessment.
Best first stop for “how does the network explore new product ideas?”
Choose the smallest set of traces that answers your question
Understand the default backbone
Start here when you want the cleanest examples of a request entering the network, getting routed, and coming back out as a usable result.
Best when: Best when your question is “how does work normally move through this system?”
What you will learn: You will see the baseline intake → route → specialist → closeout pattern, plus the moment a handoff becomes necessary.
Next if this still is not enough: Then open Network Topology if you want to see the same relationships on the map.Follow a real delivery loop
Start here when your mental model needs a real project cycle instead of a one-off request.
Best when: Best when your question is “what does autonomous execution look like over a whole charter cycle?”
What you will learn: You will see how freshness gates, design reviews, implementation, and closeout fit together without becoming separate disconnected concepts.
Next if this still is not enough: Then open Coordination if you want the owner-selection rules behind those handoffs.Understand pauses, rulings, and escalation paths
Start here when the interesting part is not the happy path, but the moment work gets blocked, slowed, or re-routed.
Best when: Best when your question is “what happens when policy or failure interrupts normal delivery?”
What you will learn: You will see the two most important interruption patterns: governance pauses before execution and operational alerts that fan out to the right responders.
Next if this still is not enough: Then open Troubleshooting if you need symptom-first recovery paths instead of example traces.Labs and experimentation
Start here when the interesting part is how raw ideas become bounded experiments, how Buzz designs distribution, and how Dexter's honest assessment informs the founding team's continue/pause/sunset call.
Best when: Best when your question is “what happens when a product idea enters Labs?”
What you will learn: You will see the full lifecycle: idea intake, experiment design with success signals and kill criteria, distribution experiments, and evidence-based assessment.
Next if this still is not enough: Then open Capabilities if you want to see what tools Dexter and Buzz actually use.Use the lower-half trace library by question, not by scroll depth
Knowledge and memory
Best for: “where did this context come from?”
Open these when the interesting part is recall, sync, indexing, or write-back into the shared knowledge layer.
Delivery and build loops
Best for: “how does a build get shipped?”
Open these when you want the implementation path from scoped task to generated code, preview URL, and shipped artifact.
Governance and lifecycle gates
Best for: “who says yes at a gate?”
Open these when work slows down because policy, rule codification, or promotion criteria need a ruling before delivery can continue.
Human loops and recovery paths
Best for: “what happens when Jake asks?”
Open these when a human request, alert, or failure path is the key teaching moment rather than the happy-path delivery flow.
Labs and experimentation
Best for: “how do ideas become experiments?”
Open these when the interesting part is how ideas become bounded experiments, how Buzz finds the audience, and how Dexter assesses what to recommend — continue, pause, or sunset — before the founding team makes the call.
Open one trace, or expand the whole library to search it
PR Review RequestJake asks Clawdy to review a pull request. Clawdy recognizes this as a GitHub task and delegates to Currybot.▶ expand
Scout Autonomous CycleEvery 4 hours, Scout's Atlas cron job fires, triggering a bounded work cycle focused on building agent network documentation.▶ expand
Knowledge Search (RAG)An agent needs to recall information from LC's knowledge base — team notes, decisions, meeting transcripts.▶ expand
Cross-Agent DelegationJake asks Clawdy to build a complex feature. Clawdy delegates to Currybot, who spawns an isolated sub-agent for the multi-hour build task.▶ expand
Meeting Notes ProcessingJake records a meeting in Fellow.app. The Atticus Ledger — an autonomous pipeline — detects new notes, processes them, stores in the knowledge base, and publishes to Notion. Zero manual trigger required.▶ expand
Governance CheckBefore taking a significant action — like deploying a new service or publishing external content — an agent consults Atticus for policy clearance.▶ expand
Design Review (Meg)Scout ships a new dashboard page and requests a design review from Meg before merging. Meg evaluates the UI against the project PDLP using screenshots and returns a prioritized punch list.▶ expand
Knowledge Layer SyncEvery 15 minutes, the RAG Sync pipeline pulls fresh content from Notion into the shared knowledge base. Atticus's Almanac role runs scheduled cycles to maintain accuracy and fix drift in the doc layer.▶ expand
Advisory Freshness GateNear the start of each cycle, Scout bridges to the Clawdy Advisor for a bounded freshness and guidance check. It is a quick, read-only gate: catch material drift if it exists, then move straight into the work.▶ expand
Forge — Workspace GenerationJake describes a new project. Scout analyzes requirements, gates with Atticus, then delegates to Forge — a sub-agent that generates a complete OpenClaw workspace from scratch. A manual multi-day setup becomes a sub-hour automated generation.▶ expand
Anvil — Rule CodificationAnvil audits existing rule sets across the network, mines PR history for emerging conventions, and proposes new governance rules. Before anything is codified, it runs through Atticus — every new rule is reviewed, approved, and logged before it ever affects agent behavior.▶ expand
Watchtower — Alert EscalationEvery two hours, the Monitor service silently polls Saffron's key services. When a service fails, a precise chain fires: the health check detects the failure, an alert is throttled through a 60-minute cooldown gate, Slack is notified, and the event is written to the observability store where Watchtower surfaces it. This workflow traces that full path — from silent cron tick to human notification.▶ expand
Currybot — Daily Team DigestEvery morning at 8 AM CT, Currybot autonomously gathers the day's GitHub activity and surfaces a scannable digest to the team Slack channel — no prompt required. This workflow shows Currybot's proactive side: cron-driven, LLM-composed, zero human input.▶ expand
Scout → Codex DelegationWhen Scout needs code written, it plans the task itself and delegates implementation to Codex CLI — a purpose-built coding agent that runs in the same container with full repo access. Scout stays clean for reasoning; Codex handles the implementation.▶ expand
Meg PDLP AuditAfter an agent ships a new page or component, Meg runs a design audit against the project's PDLP (Project Design Language Package) — checking spacing, color, typography, and component usage against the constraints she defined. This is Meg's enforcement loop: approvals reinforce patterns, failures create corrective feedback.▶ expand
Atticus Policy QueryWhen an agent needs to know whether a proposed action is permitted — a new route, a tool delegation, an architectural change — it routes the question to Atticus. Atticus consults the policy layer (PLDP, Saffron Charter Standard, prior rulings) and returns a structured ruling with rationale. This is Saffron's governance checkpoint: nothing architecturally significant ships without Atticus clearance.▶ expand
Clawdy Knowledge QueryJake asks Clawdy a question that requires institutional knowledge — project history, technical decisions, meeting outcomes, or team context. Clawdy doesn't answer from memory alone: it queries QMD (the knowledge layer) via semantic RAG search, synthesizes the retrieved context with its own reasoning, and delivers a grounded, citable answer. This is the core intelligence loop that makes Clawdy useful beyond a simple chat agent.▶ expand
Currybot — GitHub Webhook ResponseA GitHub event fires — PR opened, CI failure — and Currybot reacts immediately. No human trigger needed. The webhook path shows Currybot's autonomous reactive side.▶ expand
Meg → Currybot Design Hand-offMeg completes a design system update and sends a structured hand-off to Currybot so component implementation stays spec-accurate. This is how design decisions translate into code without ambiguity.▶ expand
Atticus → Scout Governance RedirectScout proposes adding a new Atlas route to track live agent status. Atticus flags it as out of scope — monitoring is Watchtower's domain, not an educational map. Scout accepts the redirect, updates GOALS.md, and pivots to backlog work. This is what healthy governance looks like: proposals vetted, redirected with rationale, no wasted implementation.▶ expand
Human-in-the-Loop: WhatsApp → Network ChainJake sends a single WhatsApp message asking for a project status briefing. Clawdy orchestrates Currybot, Scout, and Atticus in parallel — then synthesizes every response into one coherent reply. This is what the network looks like from Jake's perspective: one message in, the whole system moves.▶ expand
Anvil — Product Launch Rule CompilationAnvil's first real product task: Scout compiles AI rules scattered across the entire Saffron repo, Anvil synthesizes them into a canonical machine-readable rule file, and Currybot opens a PR so Jake can review and ship it. Three sub-projects. One coherent product pipeline. This is what Anvil is being built to do at scale.▶ expand
Currykit — Package Publish PipelineA developer bumps the version of a currykit package and pushes to main. GitHub Actions takes it from there: the CI workflow authenticates via GITHUB_TOKEN, builds the package, and publishes to GitHub Packages — fully automated. No manual npm publish, no secrets in developer machines. This is how @lambda-curry/currykit-* packages reach production.▶ expand
Grafton — Lifecycle SweepGrafton's hourly cron fires and tends the initiative garden: checking Seeds for promotion readiness, running the harvest loop on completed Work Items, surfacing blockers, and spawning new Draft Seeds from completed work.▶ expand
Starter Build — Design to CodeHow a Saffron Starter or LC Classic Starter component goes from Meg's PDLP through Storybook development, Scout's app layer, Atticus governance, and Currybot's PR review before it ships.▶ expand
Grafton — Harvest Loop (Deep Dive)A single Work Item reaches Done. Watch the full harvest chain: result verification, Dormant Seed wake check, new Draft Seed creation, and the originating Seed's stage update. This is how completed work composts into what comes next.▶ expand
Knowledge Layer — RAG Query Deep DiveAn agent asks a question. Watch how that question becomes a vector query, surfaces relevant chunks from the QMD knowledge base, and returns a grounded answer — all within a single bridge call.▶ expand
Forge — Workspace Generation Deep DiveScout receives a request for a new agent project. Watch how that request becomes a structured spec, passes through Forge's file generation pipeline, and lands as a fully initialized, git-committed workspace — every file, every decision, visible.▶ expand
Grafton — Seed Gate DecisionGrafton sweeps its Seeds index and encounters a work item that's hit a promotion gate — a governance checkpoint it cannot pass alone. Watch how Grafton escalates to Atticus, how the governance-operator handshake works, and what happens after a decision comes back.▶ expand
Human-in-the-Loop — Jake Overrides a Grafton DeferralAtticus defers a Grafton governance gate — the criteria are unverifiable from agent context alone. Atticus escalates to Jake via Clawdy. Jake reviews and issues a manual override. Grafton proceeds with a human-approved audit trail. This is the highest trust tier in action: humans sit above Governance.▶ expand
Atticus — Retroactive Policy AuditAtticus runs a scheduled retroactive audit: scanning past agent decisions against the current rule portfolio to surface policy drift, silent violations, and rules that need strengthening.▶ expand
Currybot Cron Failure + RecoveryCurrybot's daily digest cron fails silently. Watchtower detects the missing heartbeat, escalates to Clawdy, and Scout coordinates a recovery cycle — all without Jake getting paged unless the failure persists.▶ expand
Meg — Visual Regression CatchMeg's pre-merge design gate catches a visual regression in Storybook baselines. She blocks the PR, files a detailed issue, and routes the fix back to Scout — preventing a broken UI component from shipping.▶ expand
Grafton + Atticus — Policy ConflictGrafton escalates a gate to Atticus. Atticus's ruling conflicts with Grafton's lifecycle rule — Grafton rejects the contradiction and logs a policy conflict. Jake adjudicates via Clawdy.▶ expand
Clawdy — Conflicting Agent ResponsesA March 2026 example from Gate 2 bring-up: Jake asks a question that Scout and Currybot answer differently. Clawdy surfaces both answers, explains the discrepancy, and helps Jake decide — without pretending there's a single truth.▶ expand
Scout — Graceful Degradation + EscalationScout's cycle runs into a dependency failure mid-task. Instead of crashing or producing partial output, Scout gracefully degrades: completing what it can, checkpointing state, and surfacing a clear escalation to Jake.▶ expand
Atticus — Ambiguous Governance QueryClawdy forwards a governance question to Atticus. The question is ambiguous — it spans two policy domains. Atticus detects the ambiguity, requests clarification via Clawdy, and issues a conditional ruling once it has enough context.▶ expand
Meg — Pre-Merge Design GateA PR touching design system components triggers Meg's automated pre-merge gate. Meg runs PDLP, checks Storybook snapshots, and either approves or blocks — all before a human reviewer touches the PR.▶ expand
Clawdy — Kokoro Voice ResponseJake asks Clawdy a question and wants a voice answer. Clawdy generates a text response, synthesizes it via Kokoro TTS, and delivers an audio message back — keeping the response short and natural for listening.▶ expand
Scout — Knowledge Write-Back to QMDScout completes a research task and writes structured knowledge back to QMD — the Knowledge layer — where it becomes immediately searchable by all agents via RAG. This is how agent-generated knowledge enters the shared knowledge base.▶ expand
Grafton — New Seed EnrichmentA new seed appears in the Garden with minimal metadata — just a title and a vague description. Grafton's enrichment pass fills in owner, priority score, tags, and initial lifecycle stage, turning a stub into a actionable work item.▶ expand
Anvil — CF Pages Preview PipelineScout pushes an Atlas branch. The CF Pages GitHub Actions workflow fires, deploys a preview to Cloudflare Pages, and posts the preview URL as a PR comment — giving every branch a live preview before merge.▶ expand
Grafton — Unknown Owner Routing GapGrafton enriches a seed but cannot confidently assign an owner. It routes the item to a triage queue instead of guessing — and surfaces the gap to Jake so a human can assign ownership before the seed advances.▶ expand
Scout — Completion Gate Unblocks 5 Downstream ItemsScout completes a CF Pages audit work item. Grafton detects the completion, validates the Result Summary quality gate, and automatically unparks 5 downstream items that were blocked on this completion — then routes them all to Scout's inbox in one sweep.▶ expand
Clawdy — Memory Service PilotA new QMD collection — memory-service — is wired up as a cross-agent queryable memory store. Clawdy pilots the capability: writing structured session summaries into the collection and querying them back to surface pattern-level insights across the whole network.▶ expand
Dexter + Buzz — Labs Experiment LifecycleA new product idea arrives in Labs. Dexter shapes it into a bounded experiment with clear success signals. Buzz finds the audience and designs the distribution experiment. Results flow back to Dexter for honest assessment — continue, pause, or sunset.▶ expand
Common Patterns
Async by Default
Most workflows are asynchronous. Agents post tasks and continue other work. Results arrive via callbacks, Bridge messages, or cron checks.
Explicit Communication
No shared memory. Agents communicate via Bridge (HTTP), WhatsApp, Slack. Every handoff is explicit and logged.
Observability First
Every service boundary emits events (timing, status, metadata). Atlas now treats those workflows as traceable through the OpenObserve-backed telemetry stream, with Watchtower layering the operator-facing view on top.
Delegation Chains
Complex tasks flow through multiple agents and sub-agents. Each specializes. Delegation is cheap; specialization is valuable.