What is an MCP server for coding agents?

The Model Context Protocol (MCP) is an open protocol that lets an AI client call tools on a server over JSON-RPC 2.0. A server built for coding agents exposes the tools an agent needs while it builds software. ContextsBase exposes five: list_iterations, next_iteration_item, get_feature_spec, record_test_automation, and record_feature_implementation.

Which coding agents can connect to ContextsBase?

Claude Code, Cursor, GitHub Copilot, Windsurf, or any client that speaks the Model Context Protocol. ContextsBase does not supply an agent. You bring your own and point it at the server with a token.

What does the agent get back from next_iteration_item?

The next pending feature in the iteration, claimed atomically so two agents never take the same step. The payload carries the feature spec with its business rules, the entities it touches, the flow, the test cases, and the published theme tokens.

What are token scopes?

Each MCP token carries one or more scopes: read, write, and records. Read covers iterations and specs. Records covers the two record tools that store test results and implementation records. Hand an agent only the scopes its job needs.

What happens if I edit a spec after the agent built it?

Every implementation record carries a fingerprint of the spec it was built from. Editing the spec later marks that record Outdated. Reopening it with a note sends the step back to the queue for the agent to pull again.

How many MCP tokens do I get?

The Free plan includes one project with one MCP token, 100 features, three members, and unlimited open iterations. Premium, coming soon at $5 per month, includes unlimited projects, features, and members, with 10 MCP tokens per project and 20 open iterations.

The MCP server for coding agents that serves the spec, the tests, and the data model.

ContextsBase is an MCP server for coding agents. Claude Code, Cursor, GitHub Copilot, Windsurf, or any Model Context Protocol client connects with one token, pulls the next feature from an ordered iteration, and receives the spec, business rules, entities, flow, and test cases in a single call. When the work is done, the agent records what it built against which spec. You bring the agent. We supply what it builds from.

Create free project See how it works

Native MCP · JSON-RPC 2.0 · Scopes: read, write, records · Free for one project

your agent · JSON-RPC 2.0

→ request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": { "name": "next_iteration_item", "arguments": { … } }
}

← result
{
  feature:  "F-3 Password reset",
  spec:     [ 2 rules ],
  entities: [ User, Session ],
  flow:     "reset-password",
  tests:    [ T-7, T-8 ],
  theme:    "theme-v3"
}

Five tools. Three scopes.

The whole surface a coding agent needs to pull work and report back. Nothing to configure beyond one token.

list_iterations
read
Returns the project’s open iterations and the ordered features inside each one.
next_iteration_item
read
Claims the next pending feature atomically and returns its spec, entities, flow, test cases, and theme in one payload.
get_feature_spec
read
Returns one published feature by ID: functionality, business rules, and edge cases. Draft features are not served.
record_test_automation
records
Stores the generated Playwright test file, test name, and result against the test case it came from.
record_feature_implementation
records
Stores what the agent built, with a fingerprint of the spec it was built from.

Tokens carry scopes. Give a build agent read and records. Keep write for the people and tools that author specs.

What the server holds.

Structured objects, not prose. Each one has an ID the agent can cite in its records.

F-n

Features

Specifications with functionality, business rules, and edge cases. Draft until published; agents only read published features.

Entity

Entities

The domain data model with fields, types, and foreign keys, delivered as JSON so agents never invent a field.

Flow

Flows

Decision trees for user journeys and branching logic.

T-n

Test cases

Plain-English Given/When/Then cases that assert business rules. Agents turn them into Playwright tests and record the result.

I-n

Iterations

Ordered lists of features that agents pull from one step at a time, with atomic claims.

Theme

Colors, typography, radius, and spacing tokens designed visually and published for agents to read.

Edit

Page edits

Click-to-edit changes to a live page, saved as edits the agent applies to the real code.

Ordered like a board

Iterations are the queue agents pull from. If the task-board side is what you are evaluating, read the companion page.

Jira for AI agents

How a session runs over MCP.

You write once. The agent pulls, builds, tests, and records. ContextsBase watches for drift.

01 · YouPublished
Write the spec
Rules and test cases, published when ready.
02 · YouPending
Queue it
Add the feature to an iteration.
03 · AgentIn progress
Pull it
One call returns spec, schema, flow, tests, theme.
04 · AgentT-7, T-8 passed
Build and test
Code plus Playwright tests generated from the cases.
05 · AgentImplemented
Record it
What it built, against which spec.
06 · ContextsBaseOutdated
Watch it
Editing the spec later flags the record.

A docs MCP server and a work MCP server are different things.

Documentation platforms such as Mintlify publish an MCP server over your docs so agents can search and read them. That serves your customers’ agents. An MCP server for coding agents that build your product has a different job: hand over structured specs, take back records, and keep the queue honest.

ContextsBase is the second kind. Pricing and the full walkthrough are on the home page.

Docs MCP server

ContextsBase

What the agent reads

Published documentation pages

Structured features, entities, flows, and test cases

Direction

Agent reads

Agent reads, then records what it built

Work queue

None

Iterations with atomic claims

Tests

None

Given/When/Then cases with recorded Playwright results

Drift

Not tracked

Spec edits mark the implementation record Outdated

Built for

Your customers’ agents

Your own agents building your product

Bring your own agent. Any MCP client connects.

One line of config in the client, one token from the project. The Free plan includes one MCP token per project; Premium includes ten.

Claude CodeCursorGitHub CopilotWindsurfAny MCP client

Free, forever
1 project · 100 features · 3 members · 1 MCP token
Premium, $5 per month, coming soon
Unlimited projects, features, members · 10 MCP tokens per project
Full pricing

Questions about the MCP server.

What is an MCP server for coding agents?: The Model Context Protocol (MCP) is an open protocol that lets an AI client call tools on a server over JSON-RPC 2.0. A server built for coding agents exposes the tools an agent needs while it builds software. ContextsBase exposes five: list_iterations, next_iteration_item, get_feature_spec, record_test_automation, and record_feature_implementation.
Which coding agents can connect to ContextsBase?: Claude Code, Cursor, GitHub Copilot, Windsurf, or any client that speaks the Model Context Protocol. ContextsBase does not supply an agent. You bring your own and point it at the server with a token.
What does the agent get back from next_iteration_item?: The next pending feature in the iteration, claimed atomically so two agents never take the same step. The payload carries the feature spec with its business rules, the entities it touches, the flow, the test cases, and the published theme tokens.
What are token scopes?: Each MCP token carries one or more scopes: read, write, and records. Read covers iterations and specs. Records covers the two record tools that store test results and implementation records. Hand an agent only the scopes its job needs.
What happens if I edit a spec after the agent built it?: Every implementation record carries a fingerprint of the spec it was built from. Editing the spec later marks that record Outdated. Reopening it with a note sends the step back to the queue for the agent to pull again.
How many MCP tokens do I get?: The Free plan includes one project with one MCP token, 100 features, three members, and unlimited open iterations. Premium, coming soon at $5 per month, includes unlimited projects, features, and members, with 10 MCP tokens per project and 20 open iterations.

Something else? Ask on the support page.

Point your agent at an MCP server for coding agents that holds your spec.

One feature, one iteration, one line of config. Ten minutes.

Create free project