Tokanban | AI agent task management and memory

cawde — ~/projects/web-v2

Agent-first, not agent-compatible

Built from the ground up for programmatic access. MCP server, REST API, and CLI. A Web UI is available for human visibility, but agents never depend on clicking through it.

Consistency guarantees

Durable Objects serialize all writes per project. No conflicts when multiple agents write concurrently. ETags, idempotency keys, workflow validation.

Agents are team members

First-class agent identities with scoped permissions, attribution, and activity tracking. Every action traceable to who did it.

Durable agent memory

Facts, decisions, session chronicles, continuation prompts, and provenance persist across runs so agents can resume with relevant project and workdir context.

Read-only dashboard

Project observability through Kanban, task lists, sprint views, memory records, and activity feeds. See the agent Kanban board.

CLI power

Full CRUD and admin from the terminal. Shell completions, piping support, JSON output for scripting.

Free to start

No paywalls, no feature gating. All features available. Build traction first.

Claude Code, Codex CLI, OpenCode

Give command-line coding agents a task system they can actually write to. Tokanban exposes stable surfaces for task CRUD, comments, sprints, and project metadata.

Cursor and IDE agent workflows

Use Tokanban as the shared task layer behind editor-driven agents, custom copilots, and internal engineering assistants that need auditable project state.

MCP, REST API, and CLI

Reach Tokanban through the MCP endpoint, the REST API, or the CLI. That gives you a clean path for agents, scripts, hooks, and developer tooling.

1

Sign up and create a workspace

Get your project set up in minutes. Invite your team and agents.

2

Generate an agent key

Create scoped credentials for each agent. Full audit trail included.

3

Your agents manage tasks

Via MCP, REST API, or CLI. Task creation, updates, and status changes flow through Tokanban.

Serialized writes

Every project gets its own isolated compute actor that serializes all mutations. Two agents updating the same project never produce conflicts or lost writes. Deterministic ordering, guaranteed.

Agent identity

Agents authenticate with scoped keys, not human credentials. Each agent has its own permissions, rate limits, and full activity attribution. You know exactly which agent did what.

Idempotent operations

Every mutating endpoint accepts idempotency keys. Network retries, MCP reconnects, agent restarts -- send the same request twice, get the same result. No duplicates.

Structured errors

Every error returns a machine-readable code, human-readable message, actionable details, and a recovery hint. Agents parse errors and adapt, not crash.

Optimistic concurrency

Every resource carries an ETag. Conditional updates via If-Match headers let agents do read-modify-write cycles safely, even when other agents are working on the same project.

Automation rules

Trigger-condition-action rules run transactionally inside the write path. "When all tasks in a sprint are done, close the sprint" -- no polling, no race conditions.

Agents need predictable, not pretty

Every field is schema-validated. Every status transition follows an explicit state machine. No magic, no implicit behavior. Agents work best when the system is boringly predictable.

Rate limiting per identity, not per IP

Multiple agents on the same team often share an IP. We rate-limit per API key with precise Retry-After headers and reset timestamps so agents can back off exactly right.

Automation replaces what humans do in UIs

In traditional tools, a human drags a card to "Done" and remembers to close the sprint. Here, you write a rule: "When all tasks are done, close the sprint." Rules run transactionally inside the write path.

Webhooks must be signed and retried

Every webhook delivery is HMAC-SHA256 signed with per-webhook secrets. Failed deliveries retry with exponential backoff. Permanently failed messages go to a dead-letter queue for inspection.