The retro tool with an MCP server for AI agents
Looptro is a retrospective tool you shape to fit how your team works, and it ships a Model Context Protocol (MCP) server so AI agents like Claude Code, Cursor, and your own custom agents can join your retros as first-class participants. Point an agent at Looptro and it can read past retros, prep the board before a session, and follow up on the action items a retro produces, all through capability-scoped, revocable, team-scoped tokens with a full audit trail.
The server is live at
https://app.looptro.dev/mcp
and every tool below is real. Team accounts are still in private beta,
so agent access is not open to everyone yet.
What can an AI agent do in a retro?
Looptro's MCP tools cover the whole retro workflow: prep, the retro itself, and follow-up. What an agent can actually do is bounded by the scopes you approve when you connect it.
Read past retros
With the retros:read
scope an agent can list your team's retros, fetch a single retro's
full board (columns, posts, and action items in one call), and read
the summary narrative. That's the context an agent needs to spot
recurring themes before anyone opens the board.
Prep the board
With write scopes an agent can create a retro from a template, seed context posts, group and rename related cards, mark itself ready, and set the summary narrative. It sets the sprint cycle so the next retro lands in the right place. The team walks into a board that already has the groundwork done.
Follow up on carry-forward action items
Action items are first-class objects that carry forward to the next retro. An agent can read the open items, update their status as work lands, and file new ones, so the commitments a retro produces actually get chased between sessions instead of going stale.
Three prompts to give your agent
These are prompts a person types to an agent that has the Looptro MCP server connected. Each one names the tools it reaches and the scopes those tools need.
Find the theme that keeps coming back
Read our last five Looptro retros and list every theme that appears in more than one of them. Quote the cards you based each theme on. Change nothing.
Calls list_retros, get_retro. Needs retros:read.
Chase the open action items
List every Looptro action item that is still open. For each one, tell me which retro it came from and how many days it has been open.
Calls get_action_items, get_retro. Needs action_items:read, retros:read.
Prepare Friday's board
Create Friday's retro in Looptro from our team template. Then add one card to the first column for each action item that is still open, so the team sees what carried forward.
Calls list_team_templates, create_retro, get_action_items, add_post. Needs templates:read, retros:write, action_items:read, posts:write.
Four more prompts, covering grouping, the summary narrative, and team analytics, are in the MCP docs.
What an agent can read, and what it can change
A token carries only the scopes you approve. Grant the read scopes and the agent looks but does not touch. Grant a write scope and it acts.
What an agent can read
| What the agent reads | Tool | Scope |
|---|---|---|
| The team's retros, newest first | list_retros | retros:read |
| One retro with its columns, cards, votes, and action items | get_retro | retros:read |
| The retro summary as Markdown | get_summary | retros:read |
| The team's action items, filtered by state or by date | get_action_items | action_items:read |
| The team's curated retro templates | list_team_templates | templates:read |
| Follow-through, carry-forward, participation, and adoption rates | get_team_analytics | action_items:read, posts:read, retros:read |
get_retro returns the whole board in one call,
so an agent reads cards and action items with
retros:read alone. Team analytics gates each
of its four surfaces on its own scope and names what it withheld. Every
number it returns is an aggregate, and it never names a person.
What an agent can change
| What the agent changes | Tool | Scope |
|---|---|---|
| Creates a retro from a preset or a team template | create_retro | retros:write |
| Changes a retro's title, state, phase, or timer settings | update_retro_settings | retros:write |
| Closes a retro | close_retro | retros:write |
| Writes or clears the summary narrative | set_summary_narrative | retros:write |
| Sets its own ready flag in the current phase | set_ready | retros:write |
| Adds a card to a column | add_post | posts:write |
| Edits the body of a card it wrote | update_post | posts:write |
| Casts or removes one vote on a card | vote_on_post | posts:write |
| Groups cards, ungroups them, or renames a group | group_posts, ungroup_posts, rename_group | posts:write |
| Creates an action item | create_action_item | action_items:write |
| Updates an action item's state, owner, or due date | update_action_item | action_items:write |
| Sets or disables the team's sprint cycle | set_team_sprint_cycle | templates:write |
Write tools refuse a closed retro, except for action items, which stay
editable after the retro closes. A write scope also satisfies the
matching read requirement, so
retros:write alone lets an agent call
get_retro.
Can you connect an agent today?
Not yet, unless you are in the private beta. The MCP server runs and
every tool above is real: a request to
https://app.looptro.dev/mcp
answers with the OAuth discovery header that starts the handshake. The
blocker is the account. An agent token belongs to one team, Looptro
creates teams only for private-beta accounts, and the consent page that
issues a token is closed while the beta runs. So the handshake starts
and then stops.
We would rather tell you that now than after you spend twenty minutes on it. Add your email address to the waitlist and we tell you when team accounts open.
How do you connect an agent to Looptro?
Four steps. Step 3 needs a team account, so today it completes only for a private-beta team.
- Add the server. In Claude Code, one command does it.
Any MCP client that accepts a server URL works the same way.
claude mcp add --transport http looptro https://app.looptro.dev/mcp - Let the client find the authorization server. The first call returns a 401 that points at the OAuth discovery document. The client registers itself and starts a standard OAuth 2.0 flow with PKCE. An agent with no browser, such as a cron job or a container, falls back to the device-code flow and prints a short code instead.
- Approve the team and the scopes. The consent page asks which team the token belongs to and which scopes the agent may use. This step needs a team account, and team accounts are still in private beta.
- Check the connection. Run
/mcpin Claude Code and the server appears with the scopes you approved. Ask for a read first, such as "List our five most recent retros."
A script that cannot run OAuth uses a personal access token instead, sent as a bearer token, with the same audit attribution as the OAuth path. The step-by-step install, the OAuth discovery detail, and the full tool reference are in the MCP docs.
How is agent access secured?
An agent token, whether issued through the OAuth flow or minted by hand, carries only the access you grant and nothing more.
- Capability-scoped. A token carries only the scopes you approved. A tool call missing its required scope is refused with a 403 that names the scope, so an agent can never quietly do more than you allowed.
- Team-scoped. One token, one team. Multi-team agents install once per team, which keeps the audit trail clean.
- Revocable. Every token lives in team settings with a management UI. Revoke one and it stops working immediately.
- Bounded expiry. Tokens last up to 365 days, and you can pick the exact expiry when you mint one by hand, so access lapses on its own even if you forget.
- Rate-limited. Agents get a stricter per-token budget than human sessions, with 429 back-pressure instead of silent failure.
- Audit trail. Every tool call writes an audit row tagged as an agent action, with the token, the issuing user, the team, and any error. Agent actions sit alongside human actions in the same timeline.
What does an agent-assisted retro look like?
Say your team runs a retro every second Friday and you want your agent to take the prep off your plate:
- The day before, the agent reads last sprint's retro and its summary, then pulls the action items that carried forward and checks which ones actually shipped.
- It creates Friday's retro from your team's template and seeds a few context posts: the carry-forward items still open, and any recurring theme it noticed across the last few retros.
- It sets the summary narrative with a short "here's where we left off" note, so the team opens a board that already has the thread of the last few sprints.
- The team runs the retro through Reflect, Group, Vote, and Discuss. This is the part humans do; the agent stays out of the conversation.
- Afterward, the agent files the new action items the discussion produced and updates the status of the ones the team closed, ready to carry forward into the next retro.
Every one of those calls is scoped to what you approved and logged as an agent action, so you always know exactly what the agent touched.
Works with export and the REST API
MCP is the right surface for AI agents that need capability-scoped tool calls and an audit trail. It sits next to two other shipped connections:
- Markdown export. Open a retro's Summary tab and click
"Copy summary". That puts the retro on your clipboard as Markdown,
with the grouped posts, the vote counts, and the action items. An
agent fetches the same text with
get_summary. - REST API. A typed REST surface, described by OpenAPI, for everything that is not an agent: dashboards, custom integrations, or a bot. See the REST API docs.
Connectors for Slack and Linear are built: export a summary to Slack, and turn action items into Linear issues with two-way status sync. Both need an account, so they turn on when signups open. Native integrations with Jira, GitHub, GitLab, Microsoft Teams, and Notion are on the roadmap. An agent over MCP or the REST API wires in any other context.
Questions about AI agents and MCP
-
Which AI agents work with Looptro?
- Any agent that speaks the Model Context Protocol. Claude Code and Cursor connect out of the box, and custom agents work too because the server is standard JSON-RPC 2.0 over HTTP with OAuth 2.0 auto-discovery. If your agent can add an MCP server by URL, it can join a Looptro retro.
-
Can I connect an agent to Looptro today?
- Not yet, unless you are in the private beta. The MCP server runs at https://app.looptro.dev/mcp and answers every tool call this page describes. An agent token belongs to one team, and Looptro creates teams only for private-beta accounts, so the consent page that issues a token is closed while the beta runs. Add your email address to the waitlist on the Looptro home page and we tell you when team accounts open.
-
Is the MCP server free?
- MCP access is included on the Pro and Maxx plans. The free anonymous tier runs full retros with no signup, but it does not expose the API, MCP server, audit log, or data export, so you need a Pro or Maxx team to connect an agent.
-
Can an agent change or delete my retros?
- Only within the scopes you approve. Tokens are capability-scoped: grant read-only scopes and the agent can look but not touch; grant write scopes and it can create retros, add posts, and file action items. Any tool call missing its scope is refused with a 403, every call is written to the audit log tagged as an agent action, and you can revoke a token at any time from team settings.
-
Do I need an account to connect an agent?
- Yes. MCP access lives on the Pro and Maxx plans, which are account-based. Anonymous free-tier retros are ephemeral and do not expose an API or MCP server, so there is nothing for an agent to connect to.
-
Can an AI agent run a retro on its own, without the team?
- It can, but that is not what Looptro is for. Agents prepare the ground, surface patterns from past retros, and follow up on action items so the team spends its retro time on the conversation. The humans still run the retro.
-
How do I revoke an agent's access?
- Delete the token. Every agent token, whether minted through the OAuth flow or by hand, lives in team settings with a management UI, and revoking it takes effect immediately. Tokens also carry a bounded expiry of up to 365 days, so access lapses on its own if you forget.
Bring your agent to the retro
Connect Claude Code, Cursor, or your own agent over MCP and let it do the prep and the follow-up.