Agent run control

HeadsDown calls the play before your AI agent burns time, money, or your evening.

HeadsDown tells agents what work is worth doing now, what should wait, when to narrow, when to pause for a clean handoff, and when not to interrupt.

Good to run Keep it tight Off the clock Ready to resume

Watch the demo Create account Read the trust pages

HeadsDown call · sample agent-run decision

{
  "callKey": "keep_it_tight",
  "recommendedActionKey": "narrow_scope",
  "reasonCodes": ["short_window_remaining", "scope_growth"],
  "privacyMode": "metadata_only",
  "contentReceived": false
}

Claude Code controls the model. HeadsDown controls the run.

HeadsDown does not pick Claude's model. It tells the run whether to continue, narrow, ask, queue, wrap, or resume based on your rules and the metadata path.

How HeadsDown calls the play

The agent asks before it interrupts. HeadsDown returns a call.

The query is metadata. The response is a direction. The prompt, code, diff, logs, and conversation stay with the integration that already has them.

1

Your rules stay current

HeadsDown reads the state you already manage: working windows, focus blocks, account settings, connected-tool settings, and the current mode your tools should respect.

2

The agent sends metadata

The metadata path uses categories, counts, buckets, booleans, call keys, action keys, reason codes, opaque refs, and validation state. It is not the place to send work content.

3

HeadsDown returns the play

The run gets a structured call: continue, narrow, defer, ask for a yes, save a handoff, or resume. Stops are user-elected, not automatic.

Canonical moments

Five calls your agent can understand.

These examples are sample states unless the connected client has shipped the matching surface. They show the product language, not production proof metrics.

Keep it tight

Narrow the slice.

The task is still worth doing, but the agent should cap exploration and ship the smallest useful path.

Off the clock

Queue it for morning.

The user is unavailable. Non-urgent asks wait, and the agent saves a handoff instead of waking anyone.

Rabbit hole detected

Sample containment cue.

When scope starts expanding, the agent gets a containment signal. It narrows, asks for a yes, or prepares a handoff; it does not force a stop.

Needs your yes

Ask only when it matters.

A high-impact decision gets a clear approval surface instead of a vague mid-run interruption.

Ready to resume

Come back without rework.

The run has a saved handoff and the next decision is waiting in one reviewable place.

Off-the-clock example

Your evening stays yours.

When the user is away, HeadsDown tells the agent to defer human-input decisions, save a clean handoff, and keep working on what can safely continue.

•Non-urgent asks queue for the next reachable window.
•Human-blocking decisions become reviewable items, not after-hours pings.
•Local integration memory keeps the execution context; HeadsDown receives derived facts only.

Sample off-the-clock call

{
  "callKey": "off_the_clock",
  "recommendedActionKey": "queue_for_morning",
  "deferUntil": "next_reachable_window",
  "handoffSaved": true,
  "userInterrupted": false
}

Sample scope containment call

{
  "callKey": "keep_it_tight",
  "recommendedActionKey": "narrow_scope",
  "scopeBudget": "smallest_useful_slice",
  "validationRequirement": "targeted",
  "stopMode": "user_elected_only"
}

Rabbit-hole example

When scope expands, the agent gets better information.

HeadsDown keeps agents going. It gives the run a tighter play: reduce scope, validate one path, table the risky decision, or ask for a user-elected yes. Stops are user-elected, never automatic.

This is sample/demo behavior while final cross-client screenshots and surfaces land. It is not a production proof metric.

Guided demo

Watch HeadsDown queue the ask, then bring it back cleanly.

The demo is a scripted sample of one developer and one agent decision loop. It shows the product story without claiming production proof metrics.

Watch the demo Review AI data use

Why prompts are not enough

A prompt cannot know what changed after it was written.

Your calendar moves. Your evening starts. A run grows from small to risky. HeadsDown turns those changing constraints into calls the agent can act on.

Prompts go stale

They capture intent at launch, not the user's current window, interruptions, queue, or rule changes.

Agents need structured calls

A call key and action key are easier to follow than another paragraph of policy text.

Receipts build trust

Users can see what was queued, narrowed, or brought back, without exposing prompts or code to HeadsDown.

Proof and trust

Public claims stay tied to shipped or labeled behavior.

The trust pages explain what is live, what is draft, and what is planned. No SOC 2 claim, retention promise, data residency promise, or proof metric appears here without backing.

Let your agents run without babysitting them.

Create an account to set your rules, then watch the demo to see how supported agent integrations use HeadsDown routing decisions.

Create account Watch the demo

FAQ

Questions before you let an agent run?

: No. The metadata path uses routing facts such as task category, size buckets, opaque workspace refs, call keys, action keys, validation state, and timing. It does not need source code, prompts, conversation history, logs, repo names, or file contents.
: No. For Claude Code, Claude Code controls the model. HeadsDown controls the run: continue, narrow, queue, ask, wrap, or resume. Other integrations should only claim model-related behavior when that behavior actually ships.
: A prompt is static. HeadsDown uses current state, event metadata, and standing rules to return a structured call at the moment the agent needs one.
: The consumer app, calendar/push surfaces, API keys, agent-run event submission path, metadata validator, and calibration substrate are live. The public routing-decision endpoint, partner OAuth, developer dashboard, metering, public docs site, and some cross-client screenshots are draft or planned until labeled otherwise.