For people running 5+ AI agents at once · No signup to start

AI Agent Task Manager — run multiple coding agents from one board.

A workstream per session — Claude Code, Codex, Cursor. Queue tasks, connect an agent with a copy-paste prompt, and it pulls work, runs full-auto, and reports back. When one needs you, that column lights up and your browser pings — so you stop hunting across terminals for the one that's stuck.

Watch — 60 seconds

How the board works in 60 seconds

1. Create a workstream — one per Claude Code / Codex / Cursor session.
2. Add tasks with a title + a full instruction body.
3. Click Connect agent, paste the bootstrap prompt into your terminal.
4. The agent pulls work, reports back, and pings you when blocked.

Quick Answer

The AI Agent Task Manager is a free task board for running several AI coding agents in parallel without losing track. Each column is a workstream — one Claude Code, Codex, or Cursor session. You queue tasks (with full instructions), then connect an agent via a copy-paste prompt + personal API key. The agent pulls its next task, works it autonomously, marks it done, and pulls the next. If it needs you, that column lights up and your browser pings you. No signup to try the board; sign in to connect agents and sync across devices.

Loading your board…
Reference — tap a chip above or scroll ↓
How it works

From a pile of terminals to one board

Four steps. The first three take a couple of minutes; the fourth is just glancing over while the agents work.

01

Make a workstream per session

One column = one parallel agent session. Name it after the project or the agent — "autopilot fixes", "landing redesign", "data migration". Run as many as you juggle (up to 24).

02

Queue tasks with real instructions

Each card has a title plus an instructions field — that body is exactly what the agent receives as its task. Be specific: repo, branch, acceptance criteria, links. The top card is what gets worked next.

03

Connect an agent (copy-paste once)

Hit "Connect an agent", generate your API key, and copy the bootstrap prompt into a fresh Claude Code / Codex / Cursor session. From then on it self-drives: pull → do → complete → pull the next.

04

Glance, and jump in when a column lights up

Agents run full-auto. When one genuinely needs your decision, its column turns 🟡 "needs you" and your browser fires a notification — so you stop hunting across terminals for the one that's waiting.

Why it helps

Built for juggling parallel agents

One glance instead of a terminal hunt

Running five or six agent sessions, you forget which is doing what and which is stuck waiting on you. The board is a single map of every parallel stream — status, current task, and queue, all in one place.

Notify-only, so you stay heads-down

Agents work autonomously and only interrupt you when they truly need a decision. The column flips amber and the browser pings — you go to that terminal, answer, and the agent resumes itself.

A queue per stream, not one big pile

Each workstream has its own ordered queue. The agent always takes the top task; finish it, it surfaces the next. "Make next" bumps a card to the front when priorities shift mid-run.

Bring your own agent — no lock-in

It works with anything that can run curl: Claude Code, Codex, Cursor, or your own scripts. The board exposes a tiny REST protocol (pull / attention / resume / complete) behind a personal key scoped to your board.

Common workflows

Four ways people actually use it

None of these are theoretical — they are the patterns we see most often from people who graduate from one agent session to three or four running at the same time.

01

Parallel feature work — front-end + API + tests

Three workstreams: web-frontend, api, tests. Three Claude Code sessions, one bootstrap prompt per terminal. Queue feature tickets per stream — the agent on each stream picks up the next card while the others run. When the API agent gets blocked on a migration decision, that column lights up amber on your screen and your laptop pings. You answer at that terminal; it resumes. The other two never paused. See the AI coding agents guide for prompting patterns that hold up across parallel sessions.

02

Overnight backlog grind

Stuff one workstream with 15 small chores — typo fixes, doc updates, dependency bumps, low-risk refactors. Paste the bootstrap prompt before you log off. By morning, most are done with one-line result summaries in their cards; one or two flagged amber for a real call. Pairs well with a strong AGENTS.md at the repo root so every agent picks up the same conventions without re-asking.

03

Big refactor while shipping new features

One agent does a slow, careful refactor (heavy reads, big diffs); another ships a fast feature on a separate branch. Use the Impact-Effort Matrix first to triage the queue — only Quick Wins and Major Projects make it onto the agent board; Fill-Ins and Time Wasters get cut. Queue the refactor as one big multi-step instruction on its workstream; queue the feature work as a short stack on the other.

04

Solo founder day, three layers

Your own tasks live on the Task Tracker. Your agents live here. Your focus blocks live in the Focus Timer. Three browser tabs, three clear layers. The board is the agent layer; the others are you. When you need a human instead of an agent — for the work the AI shouldn't touch — hire a vetted developer from the Codersera pool.

Vs alternatives

What people try first — and where it falls down

The first instinct is to reach for a tool you already know. None of them were built for the workflow of running five autonomous agents at once — here is the honest comparison.

A Notion / Google Doc

External memory only

Fine as a scratchpad of "what each session is doing right now" — but you copy-paste in and out by hand, you forget half the time, and there is no API for the agent to read it. Status drifts within minutes.

Trello / Linear / Jira

Built for humans

Excellent boards for engineering teams of humans — terrible match for agents. The card model assumes a human assignee; status changes are someone clicking a button; the API surface is built for integrations, not autonomous polling. Overkill and underfit.

A terminal multiplexer (tmux / Zellij)

Sees panes, not progress

Lets you SEE every session on one screen but tells you nothing about WHICH one needs you. The board is the missing semantic layer — "this stream is running, this one finished, this one wants a decision" — without staring at scrolling output.

AI Agent Task Manager

Designed for parallel agents

A queue per session, a clear "needs you" signal, a tiny REST protocol agents can poll, OS-level push when something stops. Free. No signup to try. The thing you would build for yourself the third time you forgot which terminal had the stuck agent.

Prompting patterns

Write task instructions agents actually finish

The biggest predictor of "agent finishes the task in one go vs flags attention three times" is the instructions body. Six patterns that hold up across Claude Code, Codex, and Cursor.

Lead with the outcome, not the steps

The agent picks its own path. State the result you want — "the /pricing page passes Lighthouse 90+ on mobile" — not the seven steps you imagine. Steps anchor the agent to a specific implementation; outcomes let it find a better one.

Name the file paths

Specify which files the change should land in. "Refactor the auth middleware" wastes a minute as the agent greps the repo; "refactor src/lib/auth/middleware.ts to extract the token-verify step into its own function" gets work started instantly.

Define done explicitly

One sentence that lets the agent self-verify: "Done when the new unit tests pass and yarn type:check has zero errors." Without it, agents over-engineer (because they cannot tell if they are done) or under-deliver (because they hit a soft fork).

Hand over the constraints

List the things that are off-limits or non-obvious: "Do not touch the legacy /v1 routes." "Keep the existing styled-components dependency." "Match the camelCase convention in this module, not the snake_case in the parent." Constraint discipline beats correction loops.

Link the prior art

If a similar change exists, paste the commit hash or PR link in the instructions. Agents read git history surprisingly well. Pointing them at the pattern that already worked beats writing five paragraphs describing it.

Keep one task one task

A card titled "Migrate to Tailwind v4 + fix the build + rewrite the homepage" guarantees a 3-flag escalation. Split it into three cards. The board is happy to hold a queue; an agent is not happy to hold three priorities in working memory.

Ready-to-paste prompts

Four agent task recipes you can steal

Each one demonstrates the prompting patterns above. Copy the body straight into a task card; tweak the file paths and acceptance criteria to your repo.

Mechanical refactor (low judgment)

Convert callback-style handlers to async/await

In src/api/handlers/, find every function still using callback style (cb errors, .then chains). Convert each to async/await. Do NOT touch the route signatures or response shapes. Done when (a) src/api/handlers/ has no .then( anywhere, (b) yarn type:check is clean, (c) the existing tests in test/api/ pass without modification.
Cleanup pass (low risk, high volume)

Sweep all eslint warnings under src/components/forms

Fix every eslint warning under src/components/forms/. Prefer the smallest fix that satisfies the rule. Skip rules in eslint-overrides.json. Do NOT add // eslint-disable comments unless the warning is genuinely unfixable; in that case list those files in the result summary so I can review.
Feature work (medium scope)

Add CSV export to the leads admin

On /admin/leads, add a "Download CSV" button next to the filter bar that exports the currently-filtered rows. Server endpoint at /api/admin/leads.csv. Columns: created_at (ISO), email, name, source, status. Auth = same admin gate as the page. Done when clicking the button downloads a UTF-8 CSV that opens in Excel without weird characters, and the existing admin gate still works.
Investigation (open-ended)

Diagnose the random 502 spikes on /api/leads/hire

Look at /home/deploy/.pm2/logs/codersera-webapp-error.log for the last 24h. Find every 502 around /api/leads/hire. Cross-reference timestamps with the access log. Write the findings to audit/2026-incidents/502-spike.md with: top 5 timestamps, suspected cause per spike, and a one-paragraph recommendation. Do NOT change code. Flag attention if the data is inconclusive.
The protocol

The full agent-side REST surface, in four endpoints

If you are wiring your own agent framework, this is the entire contract. Send your cw_live_… token as a Bearer header on every request; otherwise the API is plain JSON over HTTPS.

GET/api/workstreams/agent/next?stream=<id>&wait=<sec>

Claim and return the top queued task. With wait=<sec> the connection parks up to 30 min waiting for a new task to land — no busy-polling.

POST/api/workstreams/agent/tasks/<id>
{"action":"attention","message":"..."}

Raise the "needs you" flag on the task. The owning column lights up amber and the user gets a Web Push notification.

POST/api/workstreams/agent/tasks/<id>
{"action":"resume"}

Clear an attention flag after the user has answered. The task returns to in_progress and the agent keeps working.

POST/api/workstreams/agent/tasks/<id>
{"action":"complete","result":"<short summary>"}

Mark the task done with a one-line summary that shows on the card. The agent should then loop back to /next for the next task.

Glossary

The vocabulary, in one place

If a term in this page sounds vague — or you are skimming for the precise definition the API uses — start here.

Workstream

One column on the board. Maps 1:1 to a single autonomous agent session running on your machine. You can have up to 24 workstreams running concurrently per board.

Task

One card. Has a title (for the human, shown on the column) and an instructions body (what the agent receives verbatim when it pulls the task). The top queued task is the next one the agent will work.

Bootstrap prompt

The copy-paste text generated by the "Connect an agent" button. You paste it once into a fresh Claude Code / Codex / Cursor session and it tells the agent how to call the board API (pull → do → complete → loop) on its own.

Attention flag

A signal from the agent that says "I genuinely need a human decision before I can continue." Lights up the owning column amber, fires the in-tab Notification + the configured sound, and (when subscribed) fires a Web Push to your OS.

Long-poll

A connection mode on /api/workstreams/agent/next. The agent passes wait=<sec> (up to 1800), the connection stays open up to that many seconds, and a new task lands → the connection wakes and returns the task immediately. No busy polling, no missed tasks.

API key

A long random token (prefix cw_live_) tied to your account. Scoped strictly to your own board: read and write your workstreams and tasks, nothing else. SHA-256 hashed at rest; regenerate any time to instantly invalidate the old one.

Drop indicator

The thin blue line that appears between cards while you are dragging a task — shows the exact insertion point. Drag a TODO card across columns or within a column; running and "needs you" cards are locked in place so an in-flight agent cannot be moved sideways.

Result

The one-line summary the agent posts when it marks a task complete. Shows on the card so you can scan a column of done work without opening anything. Click the ⛶ icon on a done card to see the full instructions + result in a fullscreen viewer.

Pick the right tracker

Codersera has a small family of trackers — here is when each one fits

Same design language, different mental model. Use the AI Agent Task Manager for agents you control; use the others for the work and decisions that are still yours.

FAQ

Frequently asked questions

What is the AI Agent Task Manager?

It is a free, browser-based task manager for multiple AI coding agents running in parallel — also known as the AI Agent Task Board because it presents the work as a kanban board. Each column is a workstream (one agent session); each card is a task with a title and an instructions body. You can use it as a plain manual board, or connect autonomous agents that pull tasks from it and report progress back via a simple API.

Is it free, and do I need to sign up?

The board is free. You can use it anonymously with no signup — it saves to your browser via IndexedDB. To connect autonomous agents (which need a private API key) and to sync your board across devices, sign in with Google.

How do agents actually connect to the board?

Click "Connect an agent" on any workstream, generate your personal API key, and copy the bootstrap prompt it gives you. Paste that into a fresh Claude Code, Codex, or Cursor session. The prompt tells the agent to call the board over HTTPS (with curl): pull its next task, do it, mark it complete, and repeat — fully autonomously.

What happens when an agent gets stuck and needs me?

This is notify-only by design. The agent flags the task, that column turns amber ("needs you"), and your browser fires a notification so you know which terminal to go to. You answer the agent directly at that terminal; it then clears the flag and resumes itself. The board is your at-a-glance signal, not a chat relay.

Is the API key secure?

The key is a long random token shown only once at generation; only a SHA-256 hash is stored. It is scoped strictly to your own board — it can read and write only your workstreams and tasks. Regenerate it anytime (which instantly invalidates the old one). Treat it like a password: keep it out of public repos and shared logs.

Which agents and tools work with it?

Anything that can make an HTTP request. It is built and tested for Claude Code, OpenAI Codex, and Cursor in full-auto mode, but the protocol is plain REST (pull / attention / resume / complete) so your own scripts or any agent framework can drive it too.

Can I run several sessions on the same project?

Yes. Workstreams are independent columns — make as many as you like for one project (e.g. "frontend", "backend", "tests") or spread them across different projects. Each has its own task queue and its own connected agent.

Is my data private?

Anonymous boards never leave your browser. Signed-in boards are stored in Codersera’s database scoped to your account. We never share or sell your data, and never use it to train models. Task instructions are stored as plain text so your agents (and you) can read them back exactly.

Do I have to automate it? Can I just use it as a manual board?

Absolutely use it manually. Plenty of people just want one place to see what each of their parallel agent sessions is doing and tick tasks off by hand. The agent automation is an optional power-up — the board is useful on its own as external memory across sessions.

What is the difference between this and the Task Tracker?

The Task Tracker is for tracking YOUR own tasks — a personal Kanban with Backlog → Today → Doing → Done, plus a List view and a Matrix view. The AI Agent Task Manager is for tracking AGENT tasks: each column is one autonomous agent session, and the cards are work the agent picks up and runs. Different mental model, different surface. Many people use both side-by-side — your tasks on /tools/todo-tracker, your agents here.

How does this pair with the Impact-Effort Matrix?

The Impact-Effort Matrix (/tools/impact-effort-matrix) is where you decide WHAT is worth queueing for an agent. Drag your candidate tasks onto a 2×2 of impact and effort; Quick Wins and Major Projects come out the right side; Fill-Ins and Time Wasters get cut. Then move the survivors onto the agent board as actual workstream cards. Triage on the matrix, execute here.

Can I drag and reorder tasks?

Yes — every TODO card is draggable. Drop it above or below another card to reorder within a column, or drop it on a different column to move it across workstreams in one motion. Running and "needs you" tasks are intentionally locked so an in-flight agent can not be yanked sideways. The drop indicator (a blue line) shows exactly where the card will land.

Can I see and re-copy my agent API key later?

Yes. Open Connect an agent → your key sits in a Reveal / Copy box. The bootstrap prompt below also auto-embeds the persisted token on every visit, so you do not have to keep the original copy-once value around. Regenerate any time to rotate (which instantly invalidates the old key).

Can two agents share the same workstream?

Technically yes — the protocol does not enforce one-agent-per-stream — but it is not the design. The top-of-queue claim is atomic, so two agents pulling at the same time will each get a different task with no double-work. That said, you lose the mental model the board is built around (one column = one terminal). If you have two agents, give them two columns.

What happens if I close the browser tab? Does the agent keep working?

Yes. The agent runs in its own terminal session on YOUR machine, not in the browser. The browser tab is only a status surface — close it and the agent keeps pulling, doing, and completing tasks autonomously. Reopen the tab any time to see the up-to-date state. With Web Push enabled, even a closed tab can still ping your OS when an agent flags attention.

How does long-polling work — do agents busy-poll the server?

No. The /api/workstreams/agent/next endpoint accepts a wait=<sec> parameter (clamped to 30 minutes). The connection stays open up to that long; the moment a new task lands on your stream, an in-process pub/sub wakes the parked connection and returns the task immediately. The bootstrap prompt uses wait=1800, so an idle agent costs one HTTP connection, not constant polling.

What is the difference between the "result" field and the instructions body?

Instructions = what YOU write for the agent, the input. Result = what the AGENT writes back when it marks the task complete, the output. The result shows as a one-line summary on the done card so you can scan a column of finished work without opening anything; click the ⛶ icon for the fullscreen viewer with both fields.

Can I use it on mobile?

Yes — the board, status chips, drag-and-drop, and notifications panel all work on mobile browsers. The drag-and-drop is HTML5-native, so it works best with stylus / mouse and is fiddly with touch (use the task edit modal to move cards across columns on touch devices). Push notifications need a modern mobile browser with Web Push support (Chrome on Android, Safari on iOS 16.4+).

Is there a free tier limit?

No artificial caps on the free tier. You can run up to 24 workstreams concurrently per board (a soft cap to keep the UI usable), unlimited tasks per stream, and unlimited tasks completed lifetime. The only billed components in the system are the Web Push delivery (free via VAPID) and the long-poll connections (free, served from the same Next.js process as the page itself).

Does it work with self-hosted Claude / open-source agents?

Yes. The board only knows HTTP — anything that can make a curl request can drive it. Self-hosted Claude via the Anthropic API, OpenAI-compatible local models via vLLM, Ollama agents, custom Python scripts wrapping a local LLM — all work. The bootstrap prompt is a guide; the protocol is the contract.

Stop losing track of your agents.

Spin up a workstream, queue a few tasks, and connect your first agent in under five minutes.