HeadsDown

Your agent gets stuck at 2am. You're asleep for 5 hours.

HeadsDown tells your AI agent when you'll be back, who else can help, and whether to wait or keep moving. One install. Works with any agent.

Join the Waitlist
Agent checks HeadsDown at 2:15am 
{
  "data": {
    "checkAvailability": {
      "status": "OFFLINE",
      "returnsAt": "2026-04-03T09:00:00-06:00",
      "action": "ROUTE_OR_QUEUE",
      "reason": "Offline until 9 AM. Bob is online."
    }
  }
}
Works with Claude Code, Pi-agent, Cursor, and more Open-source client code, fully auditable Native iOS & Android apps

How it works

Your agent gets a new capability: knowing when you're around and what to do when you're not.

Set your availability

Set your mode (online, deep work, offline), your working hours, and when you'll be back. HeadsDown keeps this live as your day changes.

Agent checks HeadsDown

When the agent needs you, it calls HeadsDown. One API call. It gets your status, when you're back, and who else on your team can help right now.

Agent acts on context

Back in 20 minutes? The agent waits. Gone for 5 hours? It queues the question for your morning digest, routes to a teammate, or pings your phone for a 10-second yes/no.

Your agent will need you. Here's what happens when you're not there.

Most tasks don't need human input. But the ones that do, a migration that needs approval, an ambiguous spec that needs clarification, those are the ones that get stuck.

Without HeadsDown

Your agent hits a decision point at 11pm. It has no idea you're asleep. It waits. You wake up at 6am and find it's been blocked for 7 hours on a question that would have taken 10 seconds to answer.

Multiply by every night, every meeting, every lunch break.

You're back soon

Your agent hits a decision point while you're in a 30-minute meeting. HeadsDown says: "back in 22 minutes." The agent parks the question, continues other work, and asks you the moment you return.

No notification needed. No wasted time.

Gone for hours

Your agent hits a decision point at 11pm. HeadsDown says: "offline until 9am, Bob is online." The agent can queue it for your morning digest, route to Bob, or tap your watch for a 10-second approval.

Your rules. The agent follows them.

>_
Agent needs human input
HeadsDown "Available?"
20 min · Agent waits
Hours · Phone notified
Teammate · Routed to Bob

Your phone is the control plane

Native iOS and Android apps with push notifications, home screen widgets, Apple Watch and Wear OS complications, and lock screen quick actions. When your agent needs a yes/no at 2am, it taps your wrist. When you wake up, your morning digest is waiting.

The difference between a productive overnight agent and a stuck one isn't the model. It's whether the agent knows your schedule.

See it work

Your agent sends a task proposal. HeadsDown checks your availability and returns a structured decision.

Deferred

GraphQL mutation 
mutation {
  submitProposal(input: {
    agentRef: "claude-sonnet:pi-agent"
    model: "claude-sonnet-4"
    framework: "pi"
    description: "Migrate all 12 database models to new schema"
    estimatedFiles: 12
    estimatedMinutes: 50
    sourceRef: "proposal-migration-001"
  }) {
    decision reason proposalId evaluatedAt
  }
}
HeadsDown returns 
{
  "data": {
    "submitProposal": {
      "decision": "DEFERRED",
      "reason": "Offline. 12-model migration deferred. Back at 9 AM MT.",
      "proposalId": "e5f6g7h8",
      "evaluatedAt": "2026-04-02T22:15:00Z"
    }
  }
}

Approved

GraphQL mutation 
mutation {
  submitProposal(input: {
    agentRef: "claude-sonnet:pi-agent"
    model: "claude-sonnet-4"
    framework: "pi"
    description: "Refactor auth module across 5 files"
    estimatedFiles: 5
    estimatedMinutes: 20
    sourceRef: "proposal-auth-refactor"
  }) {
    decision reason proposalId evaluatedAt
  }
}
HeadsDown returns 
{
  "data": {
    "submitProposal": {
      "decision": "APPROVED",
      "reason": "Approved: 5 files, 20 min fits current window.",
      "proposalId": "a1b2c3d4",
      "evaluatedAt": "2026-04-02T16:28:00Z"
    }
  }
}

Time estimates get more accurate the more you use HeadsDown. Every completed task reports back timing data, and the engine learns what each model and framework actually finishes in real conditions.

What's included

Install the free skill today. When you want your agent to act on your availability instead of just seeing it, upgrade.

Free

Your Agent Knows Your Schedule

Your availability gets injected into the agent's context: online, offline, deep work, and when you're back. The LLM sees it and decides what to do with it. Good for solo developers who want basic time awareness.

  • Open-source skill for Pi-agent, Claude Code, and others
  • Public availability URL you can share
  • Web UI for managing your schedule
  • CLI tool
    hd busy 2h hd offline until 9am
Lifetime Pass · $79

Your Agent Knows How to Reach You

Everything in Free, plus structured decisions via GraphQL, push notifications for blocking questions, morning digests, auto-responder rules, and team availability routing. Your agent doesn't just know your schedule. It knows what to do when you're not there.

  • Everything in Free
  • Structured decisions the agent can't hallucinate around
  • Push notifications for blocking questions (iOS + Android)
  • Morning digest: queued questions delivered when you start your day
  • Team routing: find who's online when you're not
  • Native iOS + Android app with widgets and watch complications

Beyond agents. One API for anything that needs your attention.

Slack bots

Your bot checks HeadsDown before sending a DM. No more pings at midnight.

Deploys

Your deploy tool confirms the on-call engineer is actually around before shipping.

CI/CD

Your pipeline checks if a reviewer is available before opening a PR notification.

Support routing

Route tickets to whoever's actually at their desk, not whoever's technically on shift.

Calendar sync

Your calendar reads your HeadsDown status. One source of truth for availability.

Your internal tools

Any system that can make an HTTP request can check HeadsDown first. Build it once.

One GraphQL endpoint. If it can make an HTTP request, it can check before it interrupts.

Open source where it matters

Everything on your machine is open source and auditable. The engine behind the API is the product.

headsdown-skill/src/index.ts 
// The agent checks HeadsDown before every taskimport { GraphQLClient } from "graphql-request"; const client = new GraphQLClient(HEADSDOWN_URL, {  headers: { authorization: `Bearer ${API_KEY}` },}); export async function beforeTask(task) {  const { submitProposal } = await client.request(`    mutation($input: ProposalInput!) {      submitProposal(input: $input) {        decision reason proposalId      }    }  `, {    input: {      agentRef: task.agent,      model: task.model,      framework: "pi-agent",      description: task.description,      estimatedFiles: task.files,      estimatedMinutes: task.minutes,      sourceRef: task.id,    },  });   if (submitProposal.decision === "DEFERRED") {    return task.defer(submitProposal.reason);  }  return task.proceed();}

Tap each boundary to see the corresponding code below.

View on GitHub

Why I built this

I spent three years building availability tools for teams. The whole problem was the same: people interrupt each other because they have no idea who's around, who's busy, or when someone will be back. Then I started using AI agents and realized they have the exact same problem. Agents need expectations of your schedule so they can work around you to be most effective. Same problem, new audience, and this time the integration is frictionless.

Built with Elixir + Phoenix by a solo founder who's been thinking about this problem since 2019.

Want structured decisions and team routing?

The Lifetime Pass gives your agent decisions it can't ignore, push notifications for blocking questions, morning digests, and team availability routing.

$79 one-time, forever

Lifetime access to all individual features. Join the waitlist to lock in this price.

Join the Waitlist

Your agent shouldn't have to guess.

The free skill and paid features are both launching soon. $79 lifetime price locks in for waitlist members.

Frequently asked questions

Task metadata only: description, estimated scope, model name, and framework. HeadsDown never receives your source code, prompts, agent conversation history, or file contents. After a task completes, timing data (duration, outcome) is reported back for calibration. The open-source skill code is fully auditable so you can verify this yourself.
With the free tier (context injection), yes. The LLM receives your availability as context but decides on its own. With the paid tier (structured decisions), no. The GraphQL response returns APPROVED or DEFERRED. The agent follows the decision directly. There's no prompt to reinterpret or hallucinate around.
A config file knows your schedule. HeadsDown knows your schedule changed 10 minutes ago because a meeting ran long, that your teammate just came online, and that this agent already interrupted you twice this hour. Availability is live, not static. A system prompt says "I work 9-5." HeadsDown says "back in 22 minutes, Bob is online and can review right now."
Initial decisions use conservative estimates based on task type, scope category, and the model's general performance benchmarks. As timing data flows in from your tasks and the broader user base, confidence scores increase and time estimates get more precise. The response includes a confidence field so the agent knows how much to trust it.
At launch: Pi-agent skill and Claude Code extension. The API is GraphQL over HTTP, so it's open for extension to any agent that can talk HTTP. Community-built integrations for other frameworks are welcome.
Yes. The free skill does the basic version of what HeadsDown does: it injects your availability into the agent's context. Install it, use it for a week, and decide if you want structured decisions the agent can't talk itself out of.