Build an agentic system out of the box with Kera workflows + MCP

Most “AI agent” setups are 80% plumbing: a queue, a state machine, a place to write results, some way to notify a human when something needs attention. You build all of that before the agent does a single useful thing.

Kera already is that plumbing. A workspace has projects, tickets, documents, and cycles. Workflows describe how work moves through states, with automated actions on each transition. And every one of those capabilities is exposed over MCP — the same protocol Claude Code, Claude Desktop, and Cursor speak natively.

So the “build an agent” problem collapses into two steps: point an agent at the MCP endpoint, and let a workflow drive the automation. Here’s what that looks like end to end.

1. Connect the agent

Add Kera’s MCP endpoint to your agent config. No SDK, no server to run — it’s a single stateless HTTP endpoint.

// .mcp.json
{
  "kera": {
    "url": "https://your-workspace.getkera.eu/mcp/"
  }
}

The agent now has tools to create and transition tickets, read and write documents, search work, and inspect project state. Ask it to “triage the open bugs in the API project” and it will actually do it — because the tools map one-to-one onto the same mutations the web app uses.

2. Let the workflow do the orchestration

This is the part people miss. You don’t need the agent to be the orchestrator. The workflow is. Define states, transitions, and actions once, and every ticket that moves through it fires the automation deterministically — whether a human, the app, or an agent triggered the move.

name: agentic-intake
states:
  - inbox
  - triaging
  - ready
  - in_progress
  - in_review
  - done
transitions:
  - from: inbox
    to: triaging
    actions:
      - type: assign_agent          # hand the ticket to your MCP agent
  - from: triaging
    to: ready
    actions:
      - type: require_fields
        fields: [priority, estimate]
  - from: in_review
    to: done
    actions:
      - type: set_field
        field: resolved_at
        value: "{{now}}"
      - type: notify
        message: "{{ticket.id}} shipped"

A ticket lands in inbox. The workflow moves it to triaging and hands it to the agent. The agent reads the ticket over MCP, sets priority and estimate, writes a short plan into the ticket body, and transitions it to ready. A human picks it up — or another agent does. Nothing about the agent knows the process; the process lives in the workflow.

3. Close the loop

Because mutations flow through the same durable layer as everything else, you get the parts that usually take another month to build for free:

• Audit — every transition, every field change, every agent action is recorded with the actor. You can always answer “who moved this, and when.”
• Exactly-once — retries don’t double-apply. An agent that crashes mid-task and retries won’t create duplicate work.
• Human-in-the-loop — a require_fields or a review state pauses the agent until a person signs off. The workflow enforces it; you don’t write the guard.

That’s an agentic system: an agent that plans and executes, a workflow that orchestrates and enforces, and an audit trail that makes it trustworthy — with setup measured in minutes, not sprints.

Try it

1. Create a workspace and a project.
2. Connect your agent via MCP.
3. Set up a workflow with the transitions your process needs.

Then ask your agent to start working. The scaffolding is already there.