Cursor + First-Tree

Cursor turned the editor into an agent surface — its AI reads your code, edits across files, and runs an agent loop right where you work. The piece that decides whether it feels like a teammate or a fancy autocomplete is context: what it knows about your team's decisions, not just the file in front of it. This page covers how to give Cursor that context, and how it works alongside Cursor's MCP support.

Cursor's context today: rules + MCP

Cursor already has two context mechanisms. .cursorrules holds project rules the agent should follow — style, conventions, do's and don'ts. And Cursor MCP lets you connect MCP servers that give the agent live access to external systems (databases, APIs, GitHub). Both are useful. Neither is your team's shared memory.

Where it falls short on a team

.cursorrules is local and drifts — five developers end up with five slightly different files, and the agent answers differently depending on whose machine it runs on. And it's a flat rules file: it can't capture why a decision was made, what was tried and abandoned, or who owns a part of the codebase. MCP, meanwhile, fetches the current state of a system but doesn't remember the team's choices about it. The shared, owned, evolving knowledge lives in neither.

What First-Tree adds

First-Tree is the orchestration platform where humans and agents ship together — they coordinate in shared chat threads, pick up work from GitHub issues and PRs, and read from a shared context tree: a Git repo where decisions, designs, and ownership live in Markdown nodes, organized by concern, each with an owner. That memory is shared (one source of truth, not N drifting rule files), versioned (history and review like your code), and current (a stale node is a bug). Cursor reads it; the agent now reasons from what your team actually decided.

A real Cursor workflow, off shared context

Say a developer opens Cursor to add a discount code to the billing flow. Without shared context, the agent reads the current file, infers a pattern, and writes plausible code that quietly ignores the rounding rule the team settled on six weeks ago. With the tree wired in, the same task runs like this:

• Prompt with intent"Add a percentage discount to checkout" — the always-on rule tells the agent to check the tree first.
• Agent reads the nodeIt opens context-tree/billing/proration.md and finds the decision: round half-up, in cents, before tax — plus why (a past rounding bug that under-charged customers).
• Code matches the decisionThe diff uses the team's rounding helper and applies the discount pre-tax — not the agent's default guess.
• Reviewer sees the linkThe PR references the node, so the human review is about the change, not re-litigating a settled rule.
• The next agent inherits itTomorrow, a Claude Code run on the same repo reads the same node and stays consistent.

The win isn't that Cursor got smarter — it's that it stopped re-deriving decisions the team already made. Each of Cursor's three context channels answers a different question, which is why they stack rather than compete:

Keep the rules file lean for the things that rarely change, lean on MCP for anything that's a live lookup, and let the tree carry the decisions you'd otherwise explain in a code review for the third time.

One context, every agent

Because First-Tree is framework-agnostic, the same tree that gives Cursor your context also serves Claude Code, Codex CLI, and anything else your team runs. Developers can pick their tool; the context stays consistent. That's the shared-context foundation behind running AI agent teams — and it's open source.