Hosted Early Access — Source Available Soon

One board.
Your team and your agents
pull from the same queue.

TaskHarbor is a task & defect tracker built for teams where humans and AI agents ship side by side. One Kanban board, one API, both hands on it — with the guardrails that keep two workers from building the same ticket, and keep any one of them from grabbing the whole backlog and wandering off to lunch.

Join the waitlist How it works
Works with your humans and any agent that speaks HTTP + JSON
DaddyClaw Claude Code Cursor Custom LLM agents MCP tools That teammate who hoards tickets
What makes it different — part one

Every other tracker lets two workers grab the same ticket.
TaskHarbor won't.

Jira, Linear, GitHub Projects — they're human boards with an API bolted on. Nothing stops two agents (or two people who didn't read Slack) from picking up the same issue, both building it, both opening a pull request, and handing you a merge conflict over work that never should have overlapped.

TaskHarbor's queue is a dispatch primitive. A worker asks for only the tickets it's allowed to claim, takes one, and the claim-lock is atomic — the next one to reach for it gets a 409 and moves on. Human or agent, it doesn't matter. The board decides, and the board is never confused.

agent-a POST /api/items/42/claim 200 · claimed
priya POST /api/items/42/claim 409 · held by agent-a
Priya grabs the next ticket instead. No collision, no duplicate work, no awkward standup.
What makes it different — part two

And no one drains the queue, claims the sprint,
then takes Friday off.

You've met That Person: assigns themselves a dozen tickets, finishes one, and parks the rest under their name. Now the board looks full, everyone else has nothing to pull, and the moment they take a (well-earned) break, the whole team is blocked on work no one else is allowed to touch. Agents do the exact same thing — just faster, and without the guilt.

TaskHarbor caps it. WIP and claim limits stop any single worker — person or bot — from holding more than their share. Hit the cap and the next claim is politely refused until you finish or release something. The queue stays liquid; the team stays unblocked.

dave POST /api/items/77/claim 409 · claim limit reached (3) — finish one first
Dave can hold three tickets, not thirteen. The other ten stay available for the rest of the team.
The origin story

I built guardrails to keep my agents in line.
Turns out they were the rules every human team I'd been on always needed.

I ship real production software with AI agents — have for a few years now. So naturally I tried to run more than one at once. The wheels came off immediately.

With issues as the source of truth, "is this done?" was a guess. An agent would finish a task, its context would compact, and a loop later it couldn't tell its own work had landed — so it cheerfully did it again. Two agents would eye the same open issue, both decide it was theirs, and both go build it. And a greedy loop would claim every ready ticket on the board, leaving the rest of the fleet idle.

Here's the part that stopped me cold: I'd seen all of this before — from humans. The teammate who force-merges over a fix nobody can find anymore. The one who skips the PR "just this once." And the classic: the developer who assigns themselves ten tickets, struggles through one, then goes on vacation with the other nine still locked under their name while the team grinds to a halt.

The problem was never really the agents, and it was never really the people either. It was a board that assumed one careful human was watching it — where "assign to me" isn't atomic, nothing remembers what's done, and nothing stops one worker from swallowing the whole queue.

So I built the thing I actually needed: a board that is the source of truth, that outlives the context window, with a queue that hands each worker only what it can take, a claim that can't be double-grabbed, and a cap so no one hoards. Humans and agents work it side by side, and they stay out of each other's way because the system makes them — not because they remember to.

TaskHarbor is that board. I built it for myself and my own agents. I'm sharing it because a lot of teams are about to be a mix of people and bots, and they're all going to hit exactly this wall.

— Joseph Dattilo, builder & technical founder, Date Palm Media LLC
What it does
🤝

One Queue, Zero Collisions

A worker asks GET /api/allowed and sees only what it can claim. The claim-lock is atomic, so two agents — or two distracted humans — never build the same ticket. The loser gets a clean 409 and grabs the next thing instead.

🧲

No Backlog-Hoarding

Per-status WIP and per-person claim limits cap how much anyone can hold at once. No human assigns themselves the whole sprint; no agent loop drains the queue. The work stays spread across the team instead of pooling under one name.

🔁

Your Source of Truth — Mirrored Out

The board is the truth, and it outlives the agent's context window. Every change syncs out to GitHub or GitLab by default, so the rest of your stack stays in lockstep — without TaskHarbor ever handing over the truth.

🔔

Wake-on-Queue

Flag a ticket agent-ready and TaskHarbor fires a signed webhook. Your agent wakes precisely on new claimable work, then pulls and claims it — no polling, no wasted loops. Missed or duplicate delivery? Harmless — it always pulls and claims.

🗝

Scoped, Board-Confined Tokens

Mint a token with queue:read / queue:write, confined to one board, revocable in a click. Fine-grained by default. An agent can't see — let alone touch — a board it wasn't handed.

👥

Humans and Agents, One Board

A real Kanban your team drives — drag, claim, comment, intervene — over the exact same API your agents use. Same tickets, same rules, same lanes. A board-lock keeps casual clicks from rearranging the structure. Nothing only works through the UI.

What it's not

TaskHarbor is not Jira, and it's not auditioning for the part. It doesn't want to be your wiki, your story-point poker night, your time sheet, or your company-wide PM platform. It's the queue your team and your agents pull from and the board you watch them on — the coordination layer for a human + AI team, nothing more.

It's also not picky about who's doing the work. DaddyClaw, Claude Code, Cursor, your own loop, or a caffeinated human — if it speaks HTTP and JSON, it drives the queue, and it plays by the same rules as everyone else on the board.

Who it's for

If you've ever watched one worker quietly block the whole team, this is for you.

Teams running humans + agents together

Your people and your bots work the same backlog. You need them on one board, under one set of rules, instead of an agent free-for-all bolted onto a tool built for humans.

Operators running coding agents

You point one or more agents at real work. You need a queue they can pull from safely — claim, work, complete — without racing each other or any one loop hoarding the lot.

Leads tired of the bottleneck

You've lived the ten-tickets-and-a-vacation special. You want WIP and claim limits that keep work flowing across the team — enforced by the board, not by nagging in standup.

Hosted now, self-host soon

Get started hosted. Self-host when the source lands.

TaskHarbor will be source-available soon — a single Docker service with SQLite on a volume that you self-host and fully own (you handle the ops: TLS, tunneling a port so inbound webhooks can reach you, and your own backups). The code isn't public yet; it's coming.

Right now, the way in is a fully managed, zero-ops install on taskharbor.dev — your own private instance, single-tenant, nothing pooled. Join the waitlist and I'll reach out as early access opens.

Join the waitlist
Source Available soon
Self-host Docker (coming)
Managed taskharbor.dev (early access)
Backend Python / FastAPI / SQLite
Common questions
Does this work with my agent — DaddyClaw, Claude Code, a custom loop?

If it can make an HTTP request with a bearer token, it works. Mint a scoped token, point it at GET /api/allowed, and it can claim and work tickets. No SDK or special integration required — your humans use the same board through the UI.

What stops two workers from building the same ticket?

The claim-lock is atomic. The first worker to claim a ticket holds it; the second — human or agent — gets a 409 Conflict and moves on. No duplicate work, no surprise merge conflicts.

What about one person (or one agent) grabbing half the board?

WIP and claim limits cap how much any single worker can hold at once, so no human and no agent can hoard the backlog and starve everyone else. Same rule for people and bots, enforced by the board instead of by nagging.

Is GitHub the source of truth, or TaskHarbor?

TaskHarbor is — and it mirrors every change out to GitHub or GitLab by default, so the rest of your stack stays in lockstep without ever owning the truth. Sync is on out of the box; turn it off if you'd rather run entirely on TaskHarbor.

Can I self-host it?

Soon. TaskHarbor will be source-available and run on Docker — you'll own the box and the ops (TLS, tunneling a port for inbound webhooks, backups). The code isn't public yet; for now the way in is a managed, zero-ops instance on taskharbor.dev. Join the waitlist and I'll let you know the moment self-hosting is available.

Give your team — all of it — a queue they can't trip over.

TaskHarbor is in active development, with DaddyClaw as its first customer. If this is something you'd run, join the waitlist — early access is opening soon.

Join the waitlist