Your AI agent got stuck at 2am. It didn't know you were asleep.

Give your AI tools real-time availability context so they know when to act, when to wait, and when to escalate. Setup takes about 2 minutes.

Watch the 60-second demo Create account

11:02pm · Agent hits a decision point

{
  "status": "OFFLINE",
  "returnsAt": "2026-04-03T09:00:00-06:00",
  "action": "DEFER",
  "reason": "Offline until 9 AM. Queued for morning digest."
}

11:02pm · Agent hits a decision point

{
  "status": "OFFLINE",
  "returnsAt": "2026-04-03T09:00:00-06:00",
  "action": "DEFER",
  "reason": "Offline until 9 AM. Queued for morning digest."
}

How it works

One shared availability layer across Claude Code, Pi, Cursor, VSCode, iOS, and Android.

Set your availability

hd busy 2h from your terminal. A tap on your phone. Or let Google Calendar handle it automatically. HeadsDown knows when you're online, in deep work, or gone for the night.

Your agent checks before it interrupts

Before interrupting, your agent checks once and gets a clear answer: proceed, wait, or escalate only when your rules allow it.

The right thing happens automatically

Back in 20 minutes? The agent waits. Gone until morning? It queues the question for your digest, or taps your watch for a 10-second yes/no when it is truly urgent. Your rules.

When you are unavailable, your agent still needs a decision.

This is where individual builders lose time. The hard tasks are the ones that need one quick human call. HeadsDown makes that call explicit.

Without HeadsDown

Your agent hits a decision at 11pm. It does not know you are asleep, so it stalls for hours on a question that should take 10 seconds.

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

You're back soon

Your agent hits a decision while you are in a meeting. HeadsDown says "back in 22 minutes," so the agent keeps moving and asks at the right moment.

No notification needed. No wasted time.

Gone for hours

Your agent hits a decision at 11pm. HeadsDown says "offline until 9am," so it can queue for digest and send a quick watch approval only when needed.

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 your command center

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 availability.

Watch the full story in 60 seconds

Same task, two outcomes. Without context the agent stalls. With HeadsDown it defers cleanly and closes the loop in digest.

Scene 1

Focus time starts

The agent sees Sam is busy and should avoid non-urgent interruptions.

Scene 2

Blocking question arrives

HeadsDown returns a clear defer decision instead of waking Sam up mid-focus.

Scene 3

Digest closes the loop

Sam comes back to one clear digest item and decides fast, without context switching.

Watch the demo Create account

Prefer technical details? Open a sample decision payload.

HeadsDown decision response

{
  "decision": "DEFERRED",
  "reason": "Sam is in focus mode until 12:00 PM",
  "nextAction": "Queue for digest",
  "returnsAt": "2026-04-03T12:00:00-06:00"
}

What you get today

Everything. No paywall. No "upgrade to unlock." Early access members get the full product while we're building it.

Native integrations for Claude Code, Pi, Cursor, VSCode, iOS, and Android, plus any agent that can make HTTP requests
CLI tool
hd busy 2h hd offline until 9am hd online
Google Calendar sync: your availability updates when meetings run long or focus blocks start
Structured decisions via API: APPROVED, DEFERRED, SCOPED
Push notifications for blocking questions (iOS + Android)
Morning digest: queued questions delivered when you start your day
Optional fallback routing when you choose to involve someone else
Native iOS + Android app with widgets, watch complications, and lock screen actions
Web dashboard for managing your availability and reviewing agent activity

Free to use right now. No credit card required.

HeadsDown is an API. Anything that can make an HTTP request can check your availability before it interrupts you: agents, Slack bots, deploy pipelines, CI/CD, internal tools. Start with your agent. The rest follows.

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",      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 humans. The problem was always the same: things interrupt people because they have no idea who's available. Then I started using AI agents and realized they have the exact same problem. Same gap, new audience. This time the integration is two minutes, not two quarters.

Solo founder. Elixir + Phoenix. Building in public.

Your AI tools run 24/7. You don't have to.

Create your account, connect your tool, and set interruption rules in about 2 minutes.

Create account Log in