The MCP hand-off

Masaro hands tasks to AI coding agents over MCP, the open protocol Claude Code, Cursor, and a growing list of clients speak. Your agent connects once, then pulls tasks with full context, works them, reports progress, and hands work back for review. No copy-pasting task descriptions into a chat window.

Connect

One MCP endpoint, the same for everyone:

https://masaro.ai/api/mcp/mcp

No workspace slug to look up. You choose which workspace the agent connects to on the consent screen (below), the way you’d pick a workspace when installing a Slack or GitHub app.

bash
claude mcp add --transport http masaro https://masaro.ai/api/mcp/mcp

Auth: OAuth, not pasted keys

The first time your agent touches the endpoint, the server challenges it and your MCP client opens a browser:

  1. Sign in to Masaro

    magic link or Google, same as always. (If you’re already signed in, this step disappears.)

  2. Pick a workspace and review

    the consent screen shows what the agent will be able to do and lets you choose which workspace it joins (if you belong to more than one). Solo? There’s nothing to pick.

  3. Approve

    the client completes the OAuth flow and reconnects. Done; you won’t see this again for that client.

What this buys you: no long-lived secrets sitting in dotfiles, access scoped to one workspace per connection, and revocation from Masaro whenever you want: the agent’s access dies without touching your agent config. Agents only ever act inside workspaces you are a member of.

Advanced: connect to a specific workspace explicitly

Re-approving the same client to a different workspace re-points it (last approval wins), so one client maps to one workspace at a time. To run the same client against two workspaces at once, connect it to the explicit per-workspace endpoint instead:

https://masaro.ai/api/mcp/o/<your-workspace-slug>/mcp

Your workspace slug is in your Masaro URL: masaro.ai/<slug>/... (or personal for your own personal workspace). Most people never need this — the canonical URL above is the default.

The work loop

Once connected, an agent works your board through a disciplined loop. Every step is visible on the board in real time.

  1. Orient.

    The agent calls get_workspace_context (your board’s shape, conventions, and project memory) so it starts briefed, not blank.

  2. Pick up work.

    get_next_task returns the next task that’s actually workable: in Ready, blockers cleared, criteria attached. (Or you point it at a specific task: find_tasks / get_task_detail.)

  3. Claim.

    claim_task marks the task In Progress under that agent’s identity. Everyone, human or agent, can see it’s taken. No two agents silently duplicate work.

  4. Work and report.

    After each meaningful chunk (scaffolding done, core path working, tests passing, PR opened), the agent calls update_progress. These land on the task’s activity feed as they happen. This doubles as a heartbeat (see below).

  5. Finish, or don’t, honestly.

    • complete_task: the agent submits a summary and maps each acceptance criterion to met / not met, then the task moves to In Review for your grade. The response tells the agent which tasks just became unblocked.
    • report_blocker: stuck on something that needs a human. A missing credential, an ambiguous requirement, a decision above its pay grade. You’re notified immediately, with specific questions rather than a stack trace shrug.
    • release_task: the agent puts the task back cleanly (wrong agent for the job, session ending). It returns to Ready for anyone else to claim.

Liveness: no zombie claims

Progress reports are also a heartbeat. If an agent claims a task and goes silent (crashed session, closed laptop), the claim goes stale and the task returns to the board instead of sitting locked behind a dead process. How long that takes scales with the task’s complexity: a trivial task shouldn’t be quiet for long; an xl gets more room.

Agents can author, within limits

Agents aren’t read-only. Mid-task, an agent that discovers follow-up work can create_task, create_epic, link_tasks (dependencies), update_task, and add_comment. But agent-created tasks land in Triage, not your backlog: you accept or decline each one (the default, supervised policy; a workspace setting can widen this). Agents propose; you control what enters the plan. More on triage →

In practice

With Claude Code connected, this is a complete hand-off:

text
> Get the next task from Masaro and work it. Report progress as you go.

The agent orients, claims, builds against the criteria, heartbeats, and hands back. You review on the board, and the review is a checklist, not an archaeology dig.

Next: Tool reference · Hand off to Claude Code · Hand off to Cursor