One Jira ticket, followed through every level of the org

Agents run in one layer. Everything that limits them is plain software.

Agents never call the outside world directly. Every tool call passes the policy engine and every model call passes the metered gateway. The kill switch revokes keys at those two points, so stopping an agent never depends on the agent cooperating.

• Authority flows down onlyA seat can grant at most what it holds. No seat raises its own capacity, autonomy or permissions.
• Every change has a before-stateRollback is a ledger operation, not a request to an agent.
• Humans are a budgeted resourceHuman minutes are reserved and metered like dollars, because they’re usually what runs out first.

What each level adds before handing the work down

Every level turns what it received into something more concrete. Questions go back up to whoever owns the decision. Here the coder and the tester both ask the PM, because they’re questions about product behaviour.

Each seat uses the same card: in, decides, out, escalates, scored on

Twelve phases, each a resumable step with its own trace and cost

The coder never starts writing code from the raw ticket. It first maps every acceptance criterion to a test; any criterion it can’t test is marked ambiguous and goes to the PM. This one rule catches most unclear tickets. For medium-risk work the reviewer approves the plan before any code is written, which costs about $0.40 and avoids $15 spent on the wrong approach.

restated_goal: Stop any single caller overloading /export,
  limits by plan tier, rejections visible.
acceptance_criteria_mapped:
  - 429 + Retry-After     → burst test       clear
  - per plan tier         → ?                AMBIGUOUS
  - dashboard shows count → ?                AMBIGUOUS
code_map:
  entry: src/routes/export.ts
  pattern: src/middleware/internalRateLimit.ts # ADR-017
blast_radius: platform-api only · no migration
assumptions_if_unanswered:
  - key = API key
  - internal tokens bypass

pr: platform-api#1187
summary: Org-keyed token bucket on /export,
  tier limits, 429 + Retry-After, metric.
decisions_to_respect:
  - Keyed by org, decided by Dana (PM)
    on msg_412_q1. Not a bug.
deviations_from_plan: none
where_to_look_hardest:
  - tier cache invalidation
    exportRateLimit.ts:40-72
self_check: all passed
cost_so_far_usd: 12.10

One batch of questions, each with options and a default

The coder asks everything in one message, tags each question as blocking or not, and says how many PM minutes it expects the questions to take. A PM-assist agent first answers what it can from the docs. In this case Dana picks an answer the coder didn’t expect (limit per org, not per API key), which is why asking beats assuming. The coder can suggest new acceptance-criteria wording, but only the PM can accept it.

• Batch, don’t dripAll questions in one message. coder-agent v3.1 asked one at a time and was retrained.
• Options plus a defaultThe PM can answer with one click.
• Disagreement ends in 2 messagesObjection, one reply, then the decision owner decides. The decision is recorded and binding.

Points for people, P50/P90 for the budget, minutes for the humans

An agent estimate has four parts: story points, so humans and agents share one scale; agent cost as P50 and P90, which sets the budget reservation; wall-clock time; and human minutes, which are often the real limit. The method starts from similar past jobs, applies written-down adjustments, then has three seats estimate blind.

# step 3: every adjustment is written down
base P50 (weighted median, ref class)  $12.00
× 1.15  external call with no cache
× 1.05  customer-facing (flag + rollout)
P50                                    ≈ $14.00
× 2.0   spread (coder-1's own history)
P90                                    $28.00

# human minutes, budgeted separately
PM questions + acceptance      5
reviewer (as if sampled)      15
overseer release approval     10
expected tester questions      3
buffer                        12
P90 total                     45 min

Each handoff adds context. Nothing is just forwarded.

Long chains of agents lose context at every handoff. Briefs are the fix: each has fixed fields, links to sources instead of pasting summaries, and every level adds what only it knows. Anything recorded as a decision is added to the context of every later step on that ticket.

Shares flow down by percentage; each job reserves its P90

The monthly share caps a seat’s total spend, and each job also reserves its own budget. At 80% of the reservation the agent pauses at the next step boundary and must re-estimate. At 100% the gateway refuses further model calls. The lead can top a job up from the crew reserve, but only within its own authority.

Every tool call is classified, not every agent

The policy engine checks the action’s risk against the seat’s autonomy level and risk ceiling. The result is one of three: allow, approve first, or refuse. Every decision is written to the ledger.

Work item, job, and seat occupant

Real outcomes outweigh another model’s opinion

How each failure is caught, and what happens next

Govern one crew well before adding layers