Your AI workforce lives in Kera

Everyone is building AI agents. Almost no one is building the place agents work.

An agent that can write code is easy now — Claude Code, Cursor, and a dozen others do it out of the box. The hard part is everything around a single agent: where does work come from, how does one agent avoid stepping on another, who approves the result, and how do you know what actually happened afterward. That’s not an AI problem. That’s an org problem. It’s the same problem you solved for your human team — with a project tracker, a workflow, a review step, and a paper trail.

Kera already is that place. So instead of building an “agent platform,” you just let agents work the same way your people do.

Agents are teammates, not scripts

In Kera, an agent isn’t a special new object you have to configure in a separate tool. It’s a project — the same primitive that holds your roadmap. A “Frontend Engineer” agent is a project with a short spec:

# Frontend Engineer Agent

## Responsibilities
- Read the assigned Kera issue
- Implement the change in the repo
- Run the tests
- Open a pull request
- Report back on the ticket

## Can
- Create and push feature branches
- Open pull requests

## Cannot
- Touch production
- Read unrelated repositories or secrets

## Escalates
- Ambiguous requirements
- Repeated test failures

That document is the agent. Anyone on the team can read it, edit it, and understand exactly what this teammate does and doesn’t do — no YAML dialect, no admin console. Want a Backend Engineer or a Security Reviewer too? Add another project.

Work flows to agents the same way it flows to people

You already move tickets through states: Inbox → Triage → Ready → In Progress → Review → Done. Agents plug straight into that. A ticket reaches Ready for Agent, and a lightweight coordinator — itself just a running Claude Code session — notices it, picks the right specialist, and hands off the work.

The coordinator’s whole job fits in a sentence:

Watch Kera for ready work → claim it → pick the right agent →
delegate → keep an eye on it → ask a human when unsure.

No queue to run. No dispatcher to babysit. No lock server. Kera is the source of truth for what’s ready and who’s doing it, so you can even run several coordinators at once and they won’t collide — when two try to grab the same ticket, exactly one wins and the others move on. You get that for free, because claiming a piece of work is a single atomic step in Kera, not a read-then-write race.

The human stays in the loop by design

An agent finishes, opens a pull request, and moves the ticket to Review — then it stops and waits. Your approval isn’t a nice-to-have bolted on later; it’s a state in the workflow. The agent parks there, durably, until a person clicks Approve or Request Changes. Close your laptop, come back tomorrow — the work is exactly where it was, and the moment you decide, the workflow picks up from that point.

That’s the difference between a demo and something you’d actually let near your codebase.

Everything is on the record

Because agents move work through the same durable core as everyone else, you get the trustworthy parts without building them:

• A full audit trail — every claim, every state change, every action, with the agent or person who did it. “Who changed this?” always has an answer.
• No double-work — an agent that crashes mid-task and retries won’t open two pull requests or reassign the same ticket twice.
• A timeline per run — loaded the issue, inspected the repo, created a branch, ran the tests, fixed a failure, opened PR #92. Eight minutes, thirty-seven tool calls. You can see what your workforce actually did, and how often it needed a human.

Start with one agent

You don’t need the whole fleet on day one. The point of this design is that it scales down as gracefully as it scales up:

1. Create a workspace and a project for the work.
2. Write one agent — a project with a one-page spec, like the example above.
3. Connect Claude Code to Kera over MCP and point it at your “Ready for Agent” column.
4. Add a review step to the workflow so nothing ships without your sign-off.

That’s a working AI teammate — one that picks up real tickets, does the work, opens PRs, and waits for you — running on the same board you already use. Add a second agent when you want one. The coordination, the approvals, and the history are already handled.

Kera becomes the layer where humans and a workforce of AI agents get things done together. The plumbing you’d normally spend a quarter building? It’s the tracker you’re already looking at.