Stop babysitting your AI agents.
HawkeRun is a local-first supervisor that keeps any long-running agent workflow alive: Claude, Codex, Antigravity, scrapers, batch LLM jobs, ETL, builds and test runs, anything you can run or supervise locally. It detects stalls, kills frozen workers, requeues their work, and only interrupts you for real decisions.
The supervisor is permanent. AI tools are disposable.
Free tier · No credit card · Windows, macOS & Linux
Sits above the tools you already use. Your CLIs, your keys, your machine.
Built to run unattended, on your terms
Self-healing
A frozen agent doesn't end your run. HawkeRun spots the stall, kills the dead worker and its child processes, requeues the task, and keeps going. Uncaught errors never take the daemon down.
Self-learning
Every decision and correction you make is remembered. Agents get your past redirects as context on the next run, so the same mistake doesn't happen twice.
Data stays private
Local-first. Your code, prompts, and API keys never leave your machine. HawkeRun drives the agents and subscriptions you already pay for. No proxy, no cloud middleman, no training on your data.
AI governance
Per-agent policy tiers (red / amber / green), approval gates, role-scoped permissions, and an audit trail of every action and decision. Autonomy you can actually prove.
Built for anyone who starts an agent and walks away
Researcher, data or ML engineer, ops or automation engineer, content operator, or developer. If you kick off an agent workflow and lose hours because it stalled, froze, or sat waiting for permission, this is for you.
- Leave Claude, Codex, Antigravity, or any local agent running and come back to finished work, not a frozen prompt
- Run long workflows that outlast your attention: research scrapes, batch LLM jobs, ETL, builds, test suites, generation pipelines
- Want agents to make routine decisions on their own instead of stopping to ask
- Have agents hand off and review each other's work, so nothing is marked done on one agent's say-so
- Need approvals on your phone only for the serious calls, not every step
- Get your money's worth from the LLM subscriptions you already pay for
The No-Ask Gate is the whole point
Most agents stall on a polite question and wait forever. HawkeRun rejects the stall and keeps the work moving.
- The agent says “Want me to continue?” and stops.
- You step away to lunch, a meeting, or bed.
- You come back five hours later.
- Nothing happened.
- The No-Ask Gate rejects the “Want me to continue?” stall.
- The supervisor requeues the task with a recovery packet.
- Claude picks up exactly where it left off and keeps going.
- You only get emailed if there’s a real decision.
The supervisor earns its keep while you're away
Three things that happen on their own. No prompts, no babysitting.
Self-healing
A worker froze. You didn't have to care.
Failover
One model ran out. The work didn't stop.
Decide from your phone
Only the serious calls reach you.
Durable by design, not by hope
The supervisor owns state in SQLite (WAL), hands out leased tasks, requires heartbeats, and reclaims anything that stalls.
Drop work on the mission board
Add an agent-task block to a project's markdown file, or use the CLI. The supervisor reads new task IDs and queues them. Markdown is the inbox, not the nervous system.
Workers claim leased tasks
A disposable worker (Claude, Codex, Ollama, any CLI) claims a task with a lease that expires. It must heartbeat. No output for N minutes → it's hung.
The watchdog reclaims the dead
Expired, silent, or orphaned work is killed (whole process tree, on every OS) and requeued. On crash, anything claimed or running is recovered. The loop never dies.
new → ready → claimed → running → done
├──→ failed (retries exhausted)
└──→ blocked
claimed/running → ready (lease expired | silent | orphaned)Everything you need to trust your agents unattended
Reliability primitives borrowed from production job queues, applied to disposable AI workers.
Single owner of state
One supervisor process writes SQLite in WAL mode. No multi-writer races, no corruption from agents fighting over a file.
Leases & heartbeats
Every claimed task has a lease_expires_at. No output for N minutes → hung → killed + requeued. Nothing is owned forever.
Watchdog reclaim
Polling is the safety net; file watchers just make wakeups instant. Missed FS events never stall the system.
Crash recovery
On startup, anything left claimed or running is requeued automatically. Pick up exactly where you crashed.
Whole-tree process kills
Tears down the entire process tree (taskkill /T /F on Windows, process-group signals on macOS and Linux), so orphaned npm / python / node children can't fake 'still alive.'
Any AI worker
The shell adapter runs claude -p, codex, ollama run, anything. Add adapters per tool, all sharing the same lease/heartbeat contract.
Manager escalations
Workers can wait for approval. Approve, reject, or redirect from the control panel, or from your phone via the email + Cloudflare relay.
Journal retention
events.jsonl and per-task logs rotate to timestamped archives instead of truncating. Nothing important is silently lost.
Self-healing loop
A bug in one tick is logged and the loop continues. uncaughtException and unhandledRejection don't kill the daemon.
Let agents work autonomously, and still prove what happened
HawkeRun's governance layer makes hands-off agents safe for real work today: policy tiers, role-scoped permissions, approval gates, and a complete record you can audit.
- Per-agent policy tiers: red needs approval, amber warns, green runs free
- Role-scoped permissions and allow/deny tool lists
- Full audit trail: every action, decision, and hand-off recorded
- Sign-off gates so nothing ships on one agent's say-so
Full LLM observability, in your own database
Trace every run, track every token and dollar, score every output. Cloud observability tools ship your prompts, code, and credentials to their servers. HawkeRun writes the same telemetry to infrastructure you control.
Trace every run
The full nested tree of prompt calls, tool-execution spans, responses, and hand-offs between agents.
Metrics that matter
Tokens, cost estimates, latency, and rate-limit events, per agent and per task.
Built-in evaluations
Human thumbs up/down and LLM-as-a-judge scoring on any output.
Prompt management
Store, version, and fetch the exact prompts your agents run.
Immutable audit trail
Every action, decision, and approval recorded for compliance.
vs. cloud observability tools: your data never touches our cloud, because there isn't one.
Pluggable local storage
Point HawkeRun's logs, metrics, and supervisor verdicts at the store you already run:
Inside your firewall
No raw code, prompts, or credentials leave your machine. Pipe the audit trail into Snowflake or BigQuery for cost attribution and compliance, on your terms, not a vendor's.
Approve the serious calls from your phone
Routine, reversible work runs on its own. When an agent hits a real decision (publishing, deleting, spending), HawkeRun pauses just that step and emails it to you. Approve, hold, or redirect, and work resumes the moment you tap. Try it →
- Red / amber / green tiers: only red needs you
- Every other agent keeps working meanwhile
- Reply by email: APPROVE · REJECT · REDIRECT
- The whole exchange lands in your audit trail
Publish v0.2.1 to production?
Signed installer built · all tests green · changelog ready.
Agents keep working while you decide.
No agent marks its own work done
One agent does the work, another reviews it, a check verifies the result, and HawkeRun enforces the hand-off, whether that’s a pull request, a cleaned dataset, or a finished report. Nothing reaches done on a single agent’s say-so.
Implementer
Claude · CodexDoes the work (writes code, gathers data, drafts content, runs the job) and submits it for review. Never marks its own work done.
Reviewer
Codex · ClaudeChecks the output, then signs off or sends it back with evidence, not vibes.
Verifier
Shell · test runnerRuns the check that proves it: tests pass, row counts match, the scrape returned the expected schema, the build is green. A sign-off only counts with a passing result attached.
Referee
HawkeRunEnforces the protocol. A task can't reach done until every required sign-off passes.
implementing → worker_done → verifying → review_required review_required → signed_off → done review_required → changes_requested → implementing
Sign-offs are typed (implementation, test verification, review, security, release, or human approval) and stored as signed decisions in SQLite. The event log is the source of truth; the board is generated from it.
# TASK-104 · Cloudflare email relay review required impl claude-worker-1 implementation complete verify test-runner npm test → pass review codex-reviewer-1 changes requested [x] Implementation submitted [x] Tests passed [ ] Reviewer sign-off [ ] Done > “Missing duplicate inbound email test.”
In a coding workflow, that looks like Claude implementing, Codex reviewing, and the test runner verifying. HawkeRun makes your agents communicate, review each other, and sign off, so nothing reaches done on one agent’s “trust me,” and you’re only pulled in for the truly red decisions.
Stop paying for agents that stall
You already pay for the subscriptions. Here's what stalled runs and babysitting actually cost on top.
You're losing about
$1,644/mo
HawkeRun Pro is $19/mo.
Pays for itself in under a day, about 87× what you're losing.
Simple, honest pricing
Priced per supervisor host. Start free and upgrade when your fleet grows.
Free
For trying HawkeRun locally.
- 1 local project
- 1–2 concurrent workers
- Local dashboard
- Shell worker
- Basic watchdog
- Manual CLI approvals
- File-inbox test mode
Pro
For solo operators running AI agents across real projects - code, research, data, or content.
- Unlimited local projects
- Local dashboard
- Background service installer
- No-Ask Gate & Decision Governor
- Watchdog / leases / retries
- Managed email alerts & relay
- All local adapters (Claude, Codex, Ollama)
- Local audit timeline
Power
For all-day agents that need phone approvals, deeper audit history, and managed relay.
- Everything in Pro
- Managed HawkeRun reply relay
- Phone approvals (APPROVE/REJECT/REDIRECT)
- More concurrent worker slots
- Longer audit history retention
- Daily email summary digest
- Advanced checkpoint/resume
- Git worktree automation
Team
For small teams that need shared policies, approvals, and audit history.
- Everything in Power
- Up to 5 team members
- Shared team policies
- Team dashboard & centralized logs
- Role-based approval controls
- Admin security settings
Cancel anytime. Bring your own AI / model accounts. HawkeRun does not include model usage. Local-first: your code stays on your machine.
Running in five steps
It installs locally beside your projects. Here's the whole flow, start to finish.
- 1
Create your account
Sign up free in under a minute. No credit card.
- 2
Copy your license key
Your key is waiting on the dashboard the moment you sign in.
- 3
Download HawkeRun for your OS
Grab the build for Windows, macOS, or Linux.
- 4
Run hawke init
A guided setup wizard wires up your projects and adapters.
- 5
Start supervising agents
Drop work on the mission board and walk away.
Your code never leaves your machine
HawkeRun is local-first by design. Here's exactly what does and doesn't leave your laptop.
- Your source code stays on your machine. HawkeRun runs beside your projects, not in our cloud.
- License checks send only your license key, app version, and a machine hash.
- The managed relay stores only decision metadata, never your code or prompts.
- Bring your own model and API keys.
Questions, answered
What exactly is HawkeRun?+
A durable, always-on supervisor process that lives outside your projects and keeps AI/CLI workers alive. It owns the state (an embedded SQLite database), hands out leased tasks, requires heartbeats, and a watchdog reclaims dead or stuck work. The supervisor is permanent; the AI tools are disposable workers.
How is this different from just running my agent in a loop?+
Agents don't 'listen and hope.' Every claimed task has a lease that expires, every worker must heartbeat, and silence kills a hung process. On crash recovery, anything left claimed or running is requeued. A bug in one tick is logged and the loop continues, self-healing instead of dying.
Which AI tools does it work with?+
It works best with controllable CLI tools (Claude Code, Codex, Ollama, shell scripts, test runners, and build jobs) that the included shell adapter runs directly: claude -p, codex, ollama run, anything else. They all share the same lease/heartbeat/requeue contract. GUI tools like Antigravity can be monitored with app keepalive and conversation watchdogs, but HawkeRun does not pretend every GUI app is a reliable headless worker.
Which platforms does it run on?+
Windows, macOS, and Linux. The supervisor is identical on all three; only the process-control layer differs. Tearing down a hung worker's whole process tree uses taskkill /T /F on Windows and process-group signals on macOS and Linux, and 'hawke service install' registers the supervisor with Task Scheduler, launchd, or systemd respectively so it stays alive across reboots.
How do I approve work from my phone?+
The local control panel is desktop-only by design (binds to 127.0.0.1). Phone approvals go through an email + Cloudflare relay path, so you can approve, reject, or redirect a manager escalation from anywhere.
Can I cancel anytime?+
Yes. Plans are month-to-month and you can cancel from your dashboard at any time. The Free tier is free forever.
Keep your agents working while you’re away.
Let the supervisor feed them work, catch the stalls, and requeue the dead, and stop them from wasting hours asking dumb questions.