Skip to content
LevelGrid

AI & MCP

Connect your AI

Connect Claude, ChatGPT, Cursor or Claude Code to your studio. Your AI works as you: it sees what you can see, changes what you can change, and every change it makes says “via MCP”.

Server URLhttps://levelgrid.app/mcp

Before you connect

  • Your studio decides how much. An owner or admin sets AI access in Settings → AI & MCP: Off, Read only or Read and write. New studios start at Read and write, and every connection follows a change on its next call.
  • One studio per connection. If you work in two studios, connect twice. A connection only ever sees its own studio.
  • Your AI is you. It sees the games, teams and documents you can see, with your role, and nothing else.

Connect

When you add the server, your AI app opens LevelGrid in your browser. Sign in if you need to, check the studio it names (Use another studio changes it), choose Read or Read and write, and select Allow.

Claude

Add a custom connector in Claude and paste the server URL. Claude opens LevelGrid to ask for access the first time it uses it.

Claude Code

claude mcp add --transport http levelgrid https://levelgrid.app/mcp

Then run /mcp in Claude Code and choose levelgrid to sign in.

ChatGPT

Turn on developer mode in ChatGPT’s settings, then create a connector with the server URL.

Cursor

Add the server to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project:

{
  "mcpServers": {
    "levelgrid": { "url": "https://levelgrid.app/mcp" }
  }
}

VS Code

Add the server to .vscode/mcp.json in your workspace:

{
  "servers": {
    "levelgrid": { "type": "http", "url": "https://levelgrid.app/mcp" }
  }
}

Other apps

If the app connects to remote MCP servers over HTTP, give it the server URL. If it only starts local servers, bridge it with mcp-remote:

{
  "mcpServers": {
    "levelgrid": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://levelgrid.app/mcp"]
    }
  }
}

What your AI can do

Your AI works as you. It reads what you can read and changes what you can change, with your role and your access to games and documents. What it creates, edits or comments on shows up in LevelGrid at once, as yours, marked via MCP — and notifies people the way your own changes do.

How much it can do is the lower of two answers: what your studio allows, and what you chose when you connected.

Studio setting Connected with Read Connected with Read and write
Off Nothing Nothing
Read only Reads Reads
Read and write Reads Reads and changes

A connection made with Read stays read-only when the studio opens up. In a studio that allows changes, your AI app is asked to step up the first time it tries one, so it can ask you to connect again with Read and write.

With Read and write, your AI changes the same things you can:

  • Issues — create and edit them, comment, and mark your notifications.
  • Projects — their fields, overview, milestones and health updates.
  • Initiatives — their fields, description, the projects under them and health updates. A target can be a quarter, a half, a month or a year: 2027-Q3 reads as Q3 2027.
  • Objectives — the studio’s own and each game’s, their key results, check-ins and the work linked to them.
  • Documents — their text, title, folder, team and who can open them.
  • Whiteboards — new boards on an issue, a project or in the library, and flowcharts drawn on them from Mermaid.

Descriptions, overviews and document bodies are rewritten or added to while people have them open. Projects, initiatives, objectives and documents can be archived and brought back. Lists — teams, members, projects, linked work, sharing — are added to and removed from by name, so your AI never clears what it did not mention.

What it never does

Some things stay on the screen, whoever asks. Text your AI reads — an issue, a document, a comment — can carry instructions someone else wrote, and these are the things such instructions would reach for.

  • Anything that cannot be undone

    Documents, folders, comments, attachments, objectives, key results, milestones, statuses, labels, saved views, drafts, notifications and a player’s Community data and a playtest’s reminders deleted in LevelGrid do not come back — and neither does an archived issue, which the app has no way to restore. Archiving anything else can be undone, and is open.

  • Changing who belongs, and with what role

    Roles, removing people, access to games, invitations, team rosters and who may create documents on a shelf — exactly what an instruction hidden in a document would reach for.

  • Studio settings

    The studio’s name, its games and teams, which areas are on, how objectives are run, and each game’s Discord server. The screens for these are already quick.

  • The MCP itself

    Turning AI access on or off, and disconnecting apps. An AI that switched itself off could not switch itself back on, and switching it on through the MCP is impossible by definition.

Your account, password, sessions and billing are not part of the MCP at all.

Tools

The tools the server offers, in the order it offers them. In a studio set to Read only, the ones that change things are not offered at all.

  • get_meWho am IReads

    Who this connection acts as: your name and role, the studio it is connected to, what it may do there, and the games and teams you can see. Call this first.

  • list_gamesList gamesReads

    The games in this studio you can see. Other tools take a "game" by name or slug; when you can see only one, it is the default.

  • list_teamsList teamsReads

    The teams of a game: the prefix (ART in ART-42) and the name. Ask for their workflow statuses and labels to filter issues by them.

  • list_usersList peopleReads

    The people in this studio, to assign issues to or to name in a filter. "me" always means you.

  • searchSearchReads

    Searches issues (identifier, title and description), projects, initiatives, objectives and documents you can see, across the games of this studio. Give a result’s id to fetch for the full text.

  • fetchFetchReads

    The full content of one thing, as Markdown: an id from search, an app URL, or an issue identifier like ART-42.

  • list_issuesList issuesReads

    Issues of a game — one team or all of them — narrowed by status, category, assignee ("me", a name, an e-mail, or "none"), creator, label, priority, project, initiative, due date and title text. Filters combine with AND; several values in one filter mean OR. Archived issues are left out.

  • get_issueGet an issueReads

    One issue in full: its fields, the description as Markdown, sub-issues, relations, attachments (names only), the latest comments and what happened to it.

  • save_issueCreate or edit an issueChanges things

    Creates an issue when "id" is left out — with its description in Markdown — or edits the issue "id" names (ART-42 or its URL). Fields left out stay as they are; assignees, labels and relations (blocks, blockedBy, relatedTo, duplicateOf) are added and removed in separate fields, so nothing is wiped by omission. Statuses and labels are the issue team’s, by name. It also sets the parent, the project and its milestone — the parent and every related issue are of the same team. A name it cannot find refuses the whole call before anything is saved. Editing, description replaces the description and appendToDescription adds to it. Issues are never archived or deleted through the MCP: the app has no way to bring one back. The app shows the change as made by you, via MCP.

  • list_commentsList an issue’s commentsReads

    Every comment on one issue, oldest first, with who wrote it and when.

  • save_commentComment on an issueChanges things

    Adds a comment to an issue (ART-42 or its URL), or, with "id", rewrites a comment you wrote — ids come from list_comments. Comments are plain text: line breaks are kept and Markdown is shown as typed. The app shows it as yours, via MCP, and notifies whoever follows the issue.

  • list_projectsList projectsReads

    The projects of a game, with status, latest health, lead, target date and how many issues each holds. Archived ones only when asked.

  • get_projectGet a projectReads

    One project in full: its fields, the overview as Markdown, milestones, its issues counted by category, and the latest health updates.

  • save_projectCreate or edit a projectChanges things

    Creates a project when "project" is left out — with its overview in Markdown — or edits the one "project" names (name, slug or URL). Fields left out stay as they are; teams and members are added and removed in separate fields, so nothing is wiped by omission. Editing, overview replaces the overview and appendToOverview adds to it. archived: true archives it and false brings it back; projects are never deleted through the MCP.

  • post_project_updatePost a project updateChanges things

    Posts a health update on a project: on_track, at_risk or off_track, and a few sentences on why. The newest update IS the project’s health — there is no other way to set it. The app shows it as yours, via MCP.

  • save_milestoneCreate or edit a milestoneChanges things

    Creates a milestone in a project, or — with "milestone" naming one of its milestones — renames it or moves its target date. Issues are put into a milestone with save_issue. Milestones are never deleted through the MCP.

  • list_initiativesList initiativesReads

    The initiatives of a game — the bets several projects add up to — with status, latest health and progress.

  • get_initiativeGet an initiativeReads

    One initiative in full: its fields, the description as Markdown, the projects under it with their health and progress, and the latest health updates.

  • save_initiativeCreate or edit an initiativeChanges things

    Creates an initiative — a bet several projects add up to — when "initiative" is left out, with its description in Markdown, or edits the one "initiative" names (name, slug or URL). Fields left out stay as they are; projects are added and removed in separate fields. The target is a period: 2027-Q3, 2027-H2, 2027-09, 2027 or a day. Editing, description replaces the description and appendToDescription adds to it. archived: true archives it and false brings it back; initiatives are never deleted through the MCP. Its activity shows the change as made by you, via MCP.

  • post_initiative_updatePost an initiative updateChanges things

    Posts a health update on an initiative: on_track, at_risk or off_track, and a few sentences on why. The newest update IS the initiative’s health — there is no other way to set it. The app shows it as yours, via MCP.

  • list_objectivesList objectivesReads

    The objectives of a period — the studio’s own and each game’s — with their key results and progress, in whatever methodology the studio uses (OKR, milestones or SMART).

  • get_objectiveGet an objectiveReads

    One objective in full: its key results, the work linked to it and the latest check-ins.

  • save_objectiveCreate or edit an objectiveChanges things

    Creates an objective when "id" is left out — the studio’s own (game: "company") or a game’s, in the current period unless "period" says another, with its key results — or edits the one "id" names. Fields left out stay as they are. Work that counts towards it is linked and unlinked in separate fields (initiatives, projects, issues). How many key results an objective may have is the studio’s methodology. archived: true archives it and false brings it back; objectives are never deleted through the MCP.

  • save_key_resultAdd or edit a key resultChanges things

    Adds a key result to an objective, or — with "keyResult" naming one of its key results by id or title — renames it or moves its start, target or unit. Whether one more is allowed is the studio’s methodology. The current value is not set here: record it with check_in.

  • check_inCheck in a key resultChanges things

    Records where a key result stands now — the newest check-in IS its current value; there is no other way to set it. For a boolean key result, 1 is done and 0 is not. The note says why. The app shows it as yours, via MCP.

  • list_documentsList documentsReads

    The documents of a game you can open — GDD, TDD, Art Bible and the rest — with folder, team, visibility and author. Archived ones only when asked.

  • get_documentGet a documentReads

    One document in full: the body as Markdown, its outline, and the comment threads still open.

  • save_documentCreate or edit a documentChanges things

    Creates a document in a game’s library when "id" is left out — with its body in Markdown — or edits the one "id" names (id or URL): title, summary, icon, folder, team, who can open it, and the body. Fields left out stay as they are; sharing is added and removed in separate fields. Editing, body replaces the body and appendToBody adds to it. archived: true archives it and false brings it back; documents are never deleted through the MCP.

  • get_whiteboardGet a whiteboardReads

    One whiteboard read as shapes with their words, the arrows between them (by the shapes they join) and the diagrams drawn through the MCP — named by "whiteboard", or by the issue, project or document it is on when that holds one board. It is the board as last saved, a few seconds behind someone drawing right now.

  • save_whiteboardCreate or rename a whiteboardChanges things

    Creates a whiteboard on an issue or a project, or — with neither — a whiteboard of its own in the game’s library (a document whose surface is a board, filed under a team or folder if you say so). With "whiteboard", renames it; a document’s board renames the document. Draw on it with draw_on_whiteboard.

  • draw_on_whiteboardDraw on a whiteboardChanges things

    Changes a whiteboard live — whoever has it open sees it happen. Do exactly one of: draw a flowchart ("mermaid", placed beside what is already there), redraw one you drew ("replaceDiagram" with the diagram id get_whiteboard gives, plus "mermaid"), change the words in shapes or arrows ("setText"), take shapes away ("remove" — their words and their arrows go too) or bring removed ones back ("restore"). A Mermaid FLOWCHART, drawn as real shapes the team can move and edit: `flowchart TD` (or LR, BT, RL); nodes `A[box]`, `A(rounded)`, `A([stadium])`, `A{decision}`, `A((circle))`; edges `-->`, `---`, `-.->`, `==>` with a label as `-->|text|` or `-- text -->`; chains `A --> B --> C`; `A & B --> C`; `%%` comments. Subgraphs, classes, styles and clicks are refused.

  • list_notificationsList notificationsReads

    Your inbox in this studio, newest first: assignments, comments, status changes, reminders and mentions. Only this studio’s — a connection never reads another studio’s inbox.

  • mark_notificationMark notificationsChanges things

    Marks your notifications in this studio as read, snoozes them for a while, or wakes snoozed ones — by id from list_notifications, or every unread one at once with "all". There is no marking unread again: the app has none.

  • whats_happeningWhat’s happeningReads

    What changed in a scope over a window, as data for a summary: issues created, completed and canceled; what is in progress, blocked, overdue or due within a week; recent comments; health updates; objective check-ins; and your unread notifications in this studio.

Security and privacy

  • No secret to copy. Connecting uses OAuth 2.1 with PKCE, through LevelGrid’s own sign-in. Each token is bound to this server and to one studio.
  • Checked on every call. Whether the connection still exists, whether you are still in the studio, and what the studio allows are read again on each call. Disconnecting, removing someone or turning AI access off takes effect on the next one.
  • Marked. Every change says via MCP, and Settings → AI & MCP shows which app each of your connections is.
  • Limited. Each connection gets 120 reads and 30 changes a minute, and a studio gets 600 calls a minute across all its connections. Past that, the answer says how many seconds to wait.
  • Files stay in LevelGrid. The MCP names attachments and never links to them.
  • Your AI provider sees what your AI reads. Connecting sends what your AI reads from the studio to the company behind your AI app, under your agreement with them. Whether that is allowed is your studio’s call — that is what the setting is for.

Questions and problems

“MCP access is turned off for …” — An owner or admin turned it off. Once they turn it back on in Settings → AI & MCP, your connection works again without connecting anew.

“… allows reading only.” — The studio is set to Read only. Your AI can still read.

“This connection can only read.” — You connected with Read. Connect again and choose Read and write.

“This connection was removed.” — It was disconnected in Settings → AI & MCP. Connect again.

“You are no longer a member of this studio.” — The studio removed you, so your connections to it stopped working.

“Too many changes on this connection …” — Wait the seconds the message names. The budget refills every minute.

What can my AI draw on a whiteboard? — Flowcharts, written in Mermaid: flowchart TD (or LR, BT, RL), boxes A[text], rounded boxes A(text), A([text]), decisions A{text}, circles A((text)), and arrows -->, ---, -.-> and ==>, with labels like -->|yes|. They become ordinary shapes on the board: anyone can move them, connect them or double-click to change the words. Your AI places a new diagram beside what is already there, and can redraw it, change the words in a shape or take shapes away. Subgraphs, styles and other kinds of diagram are refused.

Can I get back a shape my AI took away? — Yes: ask your AI to restore it. The board’s undo only undoes your own changes, so it cannot bring back something your AI — or a colleague — removed.

Why can’t my AI archive an issue? — An archived issue cannot be brought back in LevelGrid, so archiving one is treated like deleting it: it stays on the screen. Projects, initiatives, objectives and documents come back from the archive, so your AI can archive those.

Where does “via MCP” show? — On everything that keeps a record of who did it: an issue’s and an initiative’s activity, comments, health updates and check-ins. A project’s or a document’s fields have no activity log in LevelGrid, so a change there shows up without a mark.

“The live editor did not answer …” — A description or a document body is written through the same live connection the editor uses, and it did not respond in time. Nothing was changed. Try again in a moment.

My AI asked which team, person or game I meant. — A name that matches more than one thing comes back as a list instead of a guess. Tell your AI which.

Can my AI rewrite an issue’s description? — Yes. It reads the description, edits it and sends the whole of it back, or adds paragraphs at the end without touching the rest. Paragraphs it did not change keep their comments and images. Anyone with the issue open sees the change as it lands. If someone edits the same paragraph between your AI reading it and writing it back, your AI’s version wins.

Where are my connections? — Settings → AI & MCP lists the apps you connected to this studio, with when each was last used. Disconnect any of them there.