MCP Server

Quick Setup

Get started in under a minute. Run this command in your project directory:

npx @isteam/mcp@latest setup

The setup wizard walks you through connecting your project:

1. Checks Claude CLI and Node.js
2. Asks for your API token
3. Writes an .mcp.json entry and permission allowlist for this project
4. Asks for a 6-character agent name (e.g. LAPTP1, DEV001, HOME01) so you can tell terminals apart in the is.team dashboard
5. Asks whether to run in background daemon mode. Answer no for a normal stdio MCP that stays alive only while the terminal is open. Answer yes to install a launchd/systemd service that watches a card and auto-executes assigned tasks.

If you already have your API token, pass it directly to skip the prompt:

npx @isteam/mcp@latest setup --token ist_your_token_here

Get Your API Token

1. Go to is.team and open Account Settings
2. Navigate to the API tab
3. Select the workspaces you want the agent to access
4. Click Generate and copy the ist_xxx token

What is MCP?

MCP (Model Context Protocol) is an open standard that lets AI assistants connect to external tools and data sources. Instead of copying prompts and pasting API responses, your AI agent talks directly to is.team — reading your tasks, creating new ones, and managing your workflow in real time.

Available Tools

The MCP server exposes 57 tools across task management, canvas operations, real-time subscriptions, and workspace integrations. Tools marked with local only require the local package. Integration tools require the corresponding service to be connected in Workspace Settings → Integrations. Rate limits: remote server 10 req/min, exec endpoint 60 req/min.

Task Management

Workspace Integrations Local only

AI agents can interact with your connected services. Use list_integrations to discover which services are available in a workspace. Integration tools require the local package and are not available on the remote server.

Prerequisites

• Enable AI Integration on the board card you want to expose (card context menu → AI Integration)
• Generate an API token from Account Settings → API tab
• Find your card ID using the list_cards tool, or copy it from the AI Integration modal (e.g. col-1773256154568)

Which option should I use?

Option 1: Remote Server

The remote MCP server is hosted at https://is.team/mcp. No installation required — just add the URL to your MCP client configuration. Good for quick setup and one-off tasks, but does not support real-time subscriptions or live chat.

Claude Desktop

Add to your claude_desktop_config.json:

{  "mcpServers": {    "is-team": {      "url": "https://is.team/mcp",      "headers": {        "Authorization": "Bearer ist_your_token_here"      }    }  }}

Claude Code

Add the remote server from the CLI:

claude mcp add is-team \  --transport http \  --url https://is.team/mcp \  --header "Authorization: Bearer ist_your_token_here"

Cursor / Windsurf

Add to your project's .cursor/mcp.json or global MCP config:

{  "mcpServers": {    "is-team": {      "url": "https://is.team/mcp",      "headers": {        "Authorization": "Bearer ist_your_token_here"      }    }  }}

Option 2: Local Package (Recommended)

The local package runs as a persistent process on your machine via stdio, giving you access to all tools including real-time subscriptions and live chat. It requires Node.js and communicates with the is.team API on your behalf.

Claude Desktop

{  "mcpServers": {    "is-team": {      "command": "npx",      "args": ["@isteam/mcp"],      "env": {        "IST_API_TOKEN": "ist_your_token_here"      }    }  }}

Claude Code

claude mcp add is-team -e IST_API_TOKEN=ist_your_token_here -- npx @isteam/mcp

Background Daemon

Daemon mode runs Claude as a persistent background service on your machine. It watches a single card — any task dragged or created on that card is picked up automatically, processed by a headless claude --print subprocess, and the result is posted back to the card chat. The daemon survives terminal closure, auto-restarts on crash, and stays invisible to everyone except through the is.team UI.

Setup

Re-run the setup wizard and answer yes when it asks about background mode:

npx @isteam/mcp@latest setup

The daemon prompts add three extra steps after the regular wizard:

1. Card selector — pick the card the daemon should watch. Only tasks added to this card trigger Claude. Everything else is ignored.
2. Permission mode for the spawned Claude subprocess:
   • acceptEdits — auto-approve file edits, prompt for shell commands (recommended)
   • bypassPermissions — fully autonomous, no prompts (risky, only for trusted cards)
   • plan — planning mode only, no writes
3. Working directory — the path Claude runs in (defaults to the project directory).

Config is written to ~/.isteam/daemon.json, the service is installed and started, and the card shows an agent badge matching the 6-character label you chose.

How task dispatch works

1. The daemon subscribes to the card via Firestore and sets a baseline of existing tasks (never acts on what's already there).
2. When a new task arrives, it's queued and dispatched one at a time (no parallel spawning).
3. Claude is spawned with claude --print --permission-mode <mode> and a prompt that instructs it to read_card, work the task, then call complete_task.
4. Tasks have a 30-minute timeout. On success, failure, or timeout, the daemon posts a summary back to the card chat via chat_respond.
5. Use ask_chat from within the agent to ask the user questions — they see it in the card chat, not the terminal.

Stopping the daemon

The daemon has two stop paths, depending on whether you want it gone or just paused:

• From the is.team UI— click the agent badge on the card and confirm removal. The daemon detects the unassignment, cleans up its session and presence, and exits cleanly. launchd/systemd respect the clean exit and don't restart it. Run daemon start later or re-run the setup wizard to bring it back.
• From the CLI — use daemon stop to pause or daemon uninstall to remove the service entirely.

Management commands

Real-time Subscriptions

Use subscribe_card to watch a card for new tasks in real time. When a task is created or dragged into the card, the AI agent receives an instant notification — no polling needed.

"Subscribe to my task card and start working on any new tasks that appear."

The subscription uses Firestore real-time listeners with a 2-second settlement delay to filter out drag pass-throughs. Only tasks that remain on the card after the delay trigger a notification.

Claude Code

Launch Claude Code with the MCP server name to enable real-time subscriptions:

claude --dangerously-load-development-channels server:is-team

This starts Claude Code with the local is-team MCP server attached as a persistent channel, allowing it to receive real-time task notifications.

Claude Desktop

Claude Desktop supports real-time subscriptions out of the box. Once you add the local stdio config (Option 2), subscriptions work automatically — no extra flags needed.

Cursor / Windsurf

Add the local stdio config (Option 2) to your project's .cursor/mcp.json:

{  "mcpServers": {    "is-team": {      "command": "npx",      "args": ["@isteam/mcp"],      "env": {        "IST_API_TOKEN": "ist_your_token_here"      }    }  }}

Once connected, ask the agent to subscribe to a card. Real-time notifications will appear as the agent processes incoming tasks.

Live Chat

When an AI agent subscribes to a card, the card's built-in chat switches to MCP mode. Team members can talk directly to the agent from the is.team UI — no terminal or IDE required.

How it works

1. The agent calls subscribe_card — the card's chat indicator turns amber and shows "Claude (MCP)".
2. A team member types a message in the card chat. The message is saved to Firestore and forwarded to the subscribed agent as a chat_message notification.
3. The agent reads the message (optionally using chat_history for context), then replies with chat_respond.
4. The reply appears instantly in every team member's chat window. A "Claude is thinking..."indicator shows while waiting for the agent's response.
5. When the agent calls unsubscribe_card, the chat reverts to the default AI Card Assistant mode.

Example conversation

Agent: "Subscribe to Claude's Card and respond to chat messages."  → Agent calls subscribe_card (card turns amber)[Team member in is.team UI]:  "Create a task for fixing the login bug"  → Agent receives chat_message notification  → Agent calls create_task + chat_respond[Agent reply in chat]:  "Done! Created task #42 — Fix login bug (priority: high)"

Chat tools

Access Control

AI access is controlled per card. Enable AI Integration on a card to allow all MCP tools to interact with it — reading tasks, creating, updating, commenting, and more.

Configure from the card's context menu → AI Integration. Cards without AI Integration enabled will return a "not found" error for all tool calls except list_cards, which only requires a valid API token.

Permission Configuration

When running AI agents with Claude Code, you can control exactly which tools the agent is allowed to use — so it never asks for permission in the terminal. This is especially useful for headless or autonomous workflows.

Permission Modes

Set the agent's overall permission behavior with --permission-mode:

Tool Allow / Deny Rules

Use --allowedTools and --disallowedTools to pre-approve or block specific tools without interactive prompts:

# Pattern syntaxRead                          # All file readsEdit                          # All file editsBash(npm *)                   # npm commands onlyBash(git commit *)            # git commit onlymcp__is-team__*               # All is.team MCP toolsmcp__is-team__read_card       # Specific tool onlyWebFetch(domain:github.com)   # Domain-specific

Example Configurations

Read-only agent (safe):

claude -p "Check my tasks and summarize" \  --allowedTools "mcp__is-team__list_cards,mcp__is-team__read_card,Read"

Task management agent:

claude -p "Fix this bug and update the task" \  --allowedTools "mcp__is-team__*,Read,Edit,Bash(npm *)" \  --disallowedTools "Bash(rm *),Bash(git push *)"

Fully autonomous agent:

claude -p "Work through all sprint tasks" \  --permission-mode auto \  --allowedTools "mcp__is-team__*,Read,Edit,Bash" \  --disallowedTools "Bash(rm *),Bash(git push --force *)" \  --max-turns 50

Headless CI/CD:

claude --bare \  -p "Run tests and report results" \  --permission-mode bypassPermissions \  --allowedTools "Bash(npm test),Read,mcp__is-team__add_comment" \  --output-format json \  --max-turns 10

Persistent Rules (settings.json)

Save permission rules permanently in your .claude/settings.json so they apply to every session:

{  "permissions": {    "allow": [      "mcp__is-team__read_card",      "mcp__is-team__list_cards",      "Read"    ],    "deny": [      "Bash(rm *)",      "Bash(curl * | bash)"    ]  }}

Additional Control Flags