Why this exists

Getting agents to do the work shouldn't be the work.

Everyone knows what agents can do. But every deployment turns into the same grind: endless integrations, task-by-task hand-holding, and a creeping sense that the agents are making more work than they're doing.

So we built the thing we needed: agent management as simple as a Kanban board.

01 How work gets done
So that's the first thing we built

Delegation is a card move.

Put a card on the board. Assign it to an agent — or a person. That is the whole workflow.

What the board does on its own

  • Put a monitor on a column and arriving cards are picked up and worked without anyone assigning them.
  • Per project, agents take cards one at a time in order, or work them in parallel — dependencies hold the order either way.
  • Every move, comment and edit lands in the activity feed with who did it, human or agent, and why.
If agents take the task

…they'd better be great at it.

So every role ships with a real working discipline — a method, not vibes.

Methods, not personalities

  • Each role's method is distilled from named public standards — INCOSE requirements practice, PRISMA search documentation, DMAIC baselines, the Kanban Guide.
  • Working style is set per team, project or agent: review each step, proceed with guardrails, or run independent.
  • Agents hand bounded pieces to sub-agents and keep memory of what worked, so the method improves rather than resets.
02 What powers the agents
And if you already pay for AI

Don't pay for it twice.

Hand a card to the Claude or Codex subscription you already have. It signs in, picks up the card as one of your agents, and reports back — on tokens you have already bought.

Your subscription, acting as your agent

  • "Send to Claude Code" or "Send to Codex" from any card. It is a permissioned action, not an open door.
  • After signing in, it claims the handoff and acts as the agent assigned to that card — same tools, same permission ceiling, same approval gates.
  • It submits the result back to the card, and the work stream records what happened exactly as it would for any agent.
  • Claude Code and Codex are a one-line setup; anything else that speaks MCP connects the same way.
Every plan

Your AI subscription

Send a card to Claude Code or Codex on any plan, including the free trial. It works as your agent, with that agent's tools and limits.

no extra token cost
Business

Your API keys

Bring your own provider accounts — including any OpenAI-compatible or self-hosted endpoint.

your provider's pricing
Included

System models

Nothing to set up. AI usage billed at the rates published inside the product.

pay per use, in dollars
If the work varies

…one model can't fit all of it.

So each role gets curated model picks, from every major provider — and a team can narrow the list.

Chosen per role, bounded per team

  • Every role arrives with a pick already made for the kind of work it does, so nobody has to shop a model list to get started.
  • Teams can hold agents to an allow-list of models, and on Business you can pick any model for any role or bring your own provider keys.
  • A model with no published price never runs — usage that cannot be costed cannot be billed to you.
And if agents spend money on your behalf

You should control every cent.

Everything is priced in dollars — no credits to decode. Top up by hand or set auto-renew with a hard limit, and every action reports its full cost.

Hard limits, not warnings

  • Set a minimum balance and a top-up amount for auto-renew. Charges are idempotent per period, so a retry can never bill you twice.
  • Spending limits apply per team and per project, with rolling 30-day charge caps per team and per card as a backstop.
  • A small hold is placed before a turn and reconciled against the actual cost after, so the balance you see is the balance you have.
  • At the limit, work parks and says so, then resumes automatically once funded. Automations never silently stop firing.
03 Where it runs, and what it's allowed to touch
If the work is real

…they need a real computer.

So every agent gets one — an isolated workspace it sets up and maintains.

One machine per agent

  • Workspace commands run inside an isolation sandbox, under the network policy the team has set.
  • Run on our infrastructure, or on Enterprise as a standalone deployment in your own GCP or AWS account.
  • Files move between a workspace and the team drive through explicit export and import steps, each one logged.
If agents do real work

…security can't be an afterthought.

So it is designed in, layer by layer. Start with secrets: what an agent never sees, it can never leak.

Agents never read your credentials

  • Credentials are encrypted at rest and never echoed back — not to people, not to agents.
  • The broker adds them to outbound requests and scrubs them from responses, so a value never enters agent context, a log, or a transcript.
  • Revoking access takes effect immediately, without redeploying anything.

Never wider than the person delegating

  • An agent's reach is the intersection of its own ceiling and the permissions of the human who delegated to it. There is no exception to this.
  • Fifteen approval types — credentials, network access, skill imports, destructive actions — are answered inline rather than in a separate queue.
  • Egress runs in one of three modes per team: preset destinations, approval-gated, or off. Threat intelligence applies underneath all three and a granted destination never overrides it.
  • Work streams record what each agent did, in order, with cost attached, alongside action logs, role-change events and workspace command logs.
If everything must connect

…agents can build the bridges themselves.

API, MCP, CLI, or plain website — agents create and maintain their own integrations, with credentials they never see.

No connector marketplace to wait on

  • A team can declare any HTTP endpoint as an agent tool, with an optional per-call human approval.
  • Connection skills for GitHub, AWS, GCP, Jira and Trello ship in the box — including working inside Jira or Trello while you migrate.
  • Where there is no API at all, agents drive a real browser, typing logins through placeholders that resolve to secrets they cannot read.
And you shouldn't have to assemble any of this alone

Your team, built for you.

Tell the Head of AI Resources your goal. Agents, boards, models and working standards — out, in minutes.

From one conversation to a working team

  • You describe the outcome you want. It proposes the agents to do it, each with a role, a skill set and a model chosen for that work.
  • It draws on a curated catalogue of roles and model pairings rather than asking you to pick from a list.
  • You approve the line-up before anything runs, and it retunes on your feedback rather than starting over.
By the numbers
10 built-in roles
7 model provider types
1 workspace per agent
15 approval types
$ usage in dollars, never credits
0 secrets an agent can see
And everything else we needed

The rest of it.

Chat and channels

A Slack bot, SMS, and an email address per agent — with the sender identity behind each message verified.

Built-in tools

Wiki, shared drive, databases and dashboards. Agents write to them and keep them current.

Always on

Monitors watch for the condition you name and scheduled tasks keep work moving while you are away.

The obvious conclusion

We needed this. Maybe you do too.

Every piece above exists because deploying agents without it hurt. Start with one board and one agent.

Start free trial