Connect Claude, Cursor, or ChatGPT to your projects with MCP

For a while now, the story with AI assistants has been the same: they're brilliant in their own window and blind to everything else. Your plan lives in one place, the assistant lives in another, and you're the copy-paste bridge between them. You paste a task list into a chat, it reasons beautifully about it, and then the conversation ends and none of that reasoning makes it back into the system where the work actually lives. Our new MCP integration removes that bridge entirely. On the Pro plan, TaskNeuron runs a Model Context Protocol server that lets an AI assistant work directly against your real projects and tasks — currently in beta.

What is MCP, and why does it matter here

Model Context Protocol is an open standard for connecting AI assistants to external systems through a well-defined contract of tools and resources. Instead of an assistant guessing at your data from whatever you pasted into the prompt, it discovers a structured set of capabilities it can call — with typed inputs, predictable outputs, and clear boundaries. That structure is what turns "an assistant that talks about your projects" into "an assistant that operates on them." It's the difference between describing a move and making it.

For TaskNeuron specifically, MCP means the tool your team already reasons in — Claude, Cursor, ChatGPT, or Claude Code — can now read your backlog and change it, without you acting as the messenger between the two.

What MCP actually lets an assistant do

Once connected, your workspace shows up to the assistant as a set of structured tools and resources, not a chat transcript it has to guess at. It can list your projects, expand a project into its phases, tasks, and subtasks, create and update tasks (including subtasks and re-parenting), change status, set priority and effort, organize work into workstreams that become board swimlanes, manage file attachments on projects and tasks, and search across everything.

It can even kick off a full AI planning run from a goal. Because generation runs in the background rather than blocking, the assistant starts the job, polls it until the plan is ready, and then turns the finished plan into a real project — so "plan me a launch for this" becomes an actual populated board, not a wall of text you still have to transcribe.

A dedicated loop for coding agents

Coding agents get their own agentic-loop toolset, sized for the reality of an AI context window. Rather than dumping an entire project into the prompt, an agent can fetch a compact snapshot of a project, request the next actionable task, submit or update a work artifact like a pull request, and advance the task when it's done. That's the exact sequence that lets an agent pull work from your backlog, do it, and report back — instead of you narrating the backlog into a prompt every time it loses context.

This is what makes the backlog itself executable. The plan stops being a document the agent reads once and becomes a queue it draws from continuously, one reviewable unit at a time.

Connect once, with OAuth — no secrets pasted around

You connect a client through OAuth: you approve access in the browser, and no token ever gets pasted into the assistant itself. Open Settings → MCP on a Pro plan, copy your workspace's server URL into Claude Desktop, Cursor, or Claude Code, approve access, and ask it to list or create tasks. That's the whole setup — there's no key management, no long-lived secret sitting in a config file, and you can revoke access by disconnecting the client.

Access is entitlement-gated: it's a Pro capability, team members inherit their team's plan, and a platform administrator can enable or disable the whole integration across the account. So it scales from a solo builder wiring up their own assistant to a team that wants a single, governed on-ramp for AI.

Safe by construction: scoped and audited

Handing an AI write access to your work is only comfortable if you can bound it and see what it did. Every MCP action passes through a per-tool permission model — read versus write, gated by your workspace role — so a viewer-level connection can't quietly start editing, and a write-capable one can only touch what that role should. Nothing about "the AI did it" loosens the permissions you already trust.

And every action lands in an audit log that records which model made the call. That last detail matters more than it sounds: when several assistants and teammates are all acting on the same workspace, being able to answer "which model changed this, and when" is the difference between AI you can adopt and AI you have to police. Activity isn't just possible; it's scoped to the role and traceable after the fact.

What this unlocks in practice

Concretely, a few patterns fall out of this immediately. You can ask your assistant to triage a messy project — re-prioritize tasks, split oversized ones into subtasks, and file loose ideas into the right workstream — without leaving the chat. You can have it draft a whole plan from a goal and materialize it as a project. And for software teams, you can point a coding agent at the backlog and let it work task by task, opening pull requests as it goes.

The point of MCP isn't novelty — it's collapsing the distance between the assistant that reasons about your work and the system that actually holds it. Connect the two, and the assistant stops describing what you should do and starts doing it, on the record.