Model Context Protocol
MCP, explained — and what changed this month
The Model Context Protocol (MCP) is an open standard that lets an AI client — a coding assistant, a desktop app, an agent — connect to external systems through a common interface. A server exposes tools (actions the client may call), resources (context the client may read) and prompts; the client discovers them at runtime instead of relying on integrations written one by one. Anthropic published it in late 2024, and most AI coding tools now speak it.
For project work it means an agent can read the cards, documents and decisions of a project, and act on them, through one governed connection: an identity, a scope, a tool allowlist, an autonomy policy. This page keeps a dated log of what changes — in the protocol’s ecosystem and in Stellary’s server — and links the guides to connect each client.
Last change: September 1, 2026
The Stellary MCP server
Let your agents read and act on projects, cards and documents through MCP, under permissions.
OpenServer documentation
Transport, tokens, tool catalogue, queues, approvals and troubleshooting.
OpenWhat MCP changes for coding tools
Architecture, security questions, evaluation checklist and a rollout pattern.
OpenWhat changed
One entry per change, dated, with its source. Reviewed monthly; the most recent entry is the page’s last-modified date.
This hub opens; the Stellary MCP server gains multi-identity OAuth
MCP now has one entry point on this site: what the protocol is, what changed recently, the six client guides and the server documentation, all from one page that is reviewed monthly. It replaces the dated article as the first stop.
On the product side, the Stellary MCP server moved to a multi-identity OAuth setup: an interactive client acts as you with a personal access token, a workspace agent acts under its own agent token, and each identity carries its own project scope, tool allowlist and autonomy policy. The submission of the connector for verification on the OpenAI side is being prepared.
MCP vs REST API for agents, and honest context access
A new guide explains when an AI agent should go through MCP (discover context, choose tools dynamically) and when a REST endpoint is the right surface (provisioning, deterministic CRUD, webhooks) — most serious setups need both.
Agents connected through MCP also gained an honest view of their context: what they can reach is stated up front, what they cannot reach is refused visibly instead of silently, and stale context decays instead of being served as current.
Listed on the official MCP registry; six client guides published
The Stellary project management server is listed on the official Model Context Protocol registry, which lets compatible clients discover it without hand-written configuration.
Six step-by-step integration guides went live the same day — Claude Code, Codex, Cursor, Claude Desktop, LM Studio and AnythingLLM — each with the token to issue, the configuration to paste and the first mission to run. The three MCP articles on the blog were reviewed and updated.
Tool access profiles and a mission gateway for MCP agents
Every agent now runs under a tool access profile: direct, allowlisted or proposal-only per tool. MCP missions go through a gateway that enforces the profile server-side, and Stellary Desktop enforces the same rules for agents running on a local machine. A capability an agent does not have is refused with a visible reason, not simulated.
Guide: what MCP changes for AI coding tools
A practical guide to MCP for coding assistants: the architecture (client, server, tools, resources, transports), how a coding workflow changes when context becomes addressable, the security questions to ask before connecting a server, and an evaluation checklist. Reviewed on 27 July 2026.
MCP server documentation published
The reference documentation for the Stellary MCP server: Streamable HTTP transport, personal and agent tokens, the tool catalogue (projects, cards, documents, missions, approvals), queues and troubleshooting. An explainer on the protocol itself had been published a week earlier.
Connect your client
Six guides, one per client: the token to issue, the configuration to paste, the first mission to run.
Claude Code
Give Claude Code a real project queue, linked repository, card context, and a visible path from mission to review instead of managing work across terminal sessions.
Set up the integrationCodex
Queue coding work as project cards, run Codex on the machine that owns the repository, and keep mission progress, questions, failures, and results visible to the team.
Set up the integrationCursor
Use Cursor as a local coding runner or connect the editor to Stellary MCP so project context, card actions, and execution stay tied to the same workspace.
Set up the integrationClaude Desktop
Bring live Stellary projects, cards, documents, and controlled actions into Claude Desktop without copying the workspace into a separate conversation.
Set up the integrationLM Studio
Use models served by LM Studio as local Stellary execution targets while the project, cards, documents, assignments, and results remain in the shared workspace.
Set up the integrationAnythingLLM
Connect an AnythingLLM local server to the Stellary workspace catalog and use compatible models for project missions without separating execution from cards and review.
Set up the integrationQuestions about MCP
What is MCP in AI tools?
The Model Context Protocol is an open standard through which an AI client (Claude Code, Cursor, Claude Desktop, Codex and others) connects to external systems. A server exposes tools, resources and prompts; the client discovers and uses them at runtime, with the user’s identity and permissions.
MCP or REST API: which one should an agent use?
MCP when the agent needs to discover context and choose tools dynamically; a REST API when software needs a deterministic endpoint and an explicit request flow (provisioning, CRUD, webhooks). Stellary exposes both, and most serious setups use both.
Which MCP servers are worth connecting to Claude Code?
Start narrow: the server of the system your work actually lives in (your project tool, your repository host, your documentation), with read tools first and one reversible write behind approval. Stellary’s server exposes projects, cards, documents and missions; the guide for Claude Code shows the configuration in three steps.
Is MCP secure?
The protocol carries the identity and the permissions the client presents; security depends on the server. Ask before connecting one: which identity does it act under, what scope, which tools can write, is there an audit trail, can a write be put behind approval. The Stellary server answers each with an explicit setting.