How to Connect Claude and Codex to Stokik with MCP

AI agents are useful when they can see the real shape of the work.

That is the reason Stokik supports MCP. Instead of asking Claude or Codex to work from a pasted summary, you can connect the agent to a Stokik project. The agent can read the canvas, understand the tasks and documents, run from inside your codebase, draw labeled dependencies, and record progress back into the project.

Stokik stays the source of truth. The agent becomes another way to execute the plan.

What MCP gives the agent

When you connect an MCP client to Stokik, the client can use a set of Stokik tools.

It can read projects, tasks, documents, and canvas edges. It can create tasks, write structured documents, add labeled connections between tasks, update statuses, and record agent progress. It can also create a new project from a plan, including the initial tasks, documents, and dependencies.

That works in two directions:

• from an agent session, create or improve the Stokik plan
• from an existing Stokik project, run a CLI agent in a codebase and let the project guide execution

The important part is that this is not just a text export. Stokik gives the agent structured project context:

• tasks have status, position, description, and linked documents
• documents are stored as structured editor content
• edges connect tasks and can carry labels such as blocks, depends on, or unblocks
• agent runs record what the external client is doing over time

That structure is what lets an agent work with the plan rather than around it.

Step 1: Create an MCP token

Open Stokik and go to:

Settings -> MCP Integrations

Create a new token. Give it a name that identifies the client you are connecting, such as Claude Code or Codex.

Copy the token when it is shown. Stokik only shows the raw token once. You can revoke it later from the same settings page.

MCP tokens are user-scoped. The connected client can only access projects and actions that your Stokik account can access.

Step 2: Connect Claude Code

If you are using Claude Code with HTTP MCP support, add Stokik as a remote MCP server:

claude mcp add --transport http stokik https://api.stokik.com/mcp/ --header "Authorization: Bearer stokik_mcp_..."

Then start a new Claude Code session so it refreshes the available tool list.

Step 3: Connect Codex

For Codex, store the token in an environment variable and add the MCP server:

export STOKIK_MCP_TOKEN="stokik_mcp_..."
codex mcp add stokik --url https://api.stokik.com/mcp/ --bearer-token-env-var STOKIK_MCP_TOKEN
codex mcp list

Start a new Codex session after adding the server. Existing sessions may have already cached the MCP tool list.

Step 4: Start from a Stokik project

Once connected, ask the agent to list your projects or inspect a specific project.

For example:

Use Stokik MCP. List my projects, then inspect the project named "Checkout Revamp".
Summarize the current tasks, documents, dependencies, and blockers.

If you already know the project, you can be more direct:

Use Stokik MCP to inspect this project. Read the tasks, documents, and edges.
Explain the current plan and identify missing dependencies.

The best prompts mention edges explicitly. Stokik plans are not just task lists. The relationships between tasks are part of the plan.

Step 5: Execute from a codebase

The most useful workflow is often not “create a plan from scratch.” It is: open a repo, start Claude Code or Codex, connect Stokik MCP, and ask the agent to use a Stokik project as the live implementation brief.

For example:

Use Stokik MCP and inspect the project named "Checkout Revamp".
Then inspect this codebase.

Pick the next task that is ready to implement, explain which files are relevant,
make the smallest safe code change, update the task status, and record progress
back to Stokik.

For larger work, be more explicit:

Use Stokik MCP as the project source of truth.

Before editing code:
- read the project tasks, documents, and edges
- identify the task you are implementing
- start an agent run

While working:
- update task status as you move from todo to in_progress to done
- add implementation notes to the linked document
- create labeled edges if you discover new dependencies
- record progress after each meaningful code change

Do not delete Stokik tasks or documents.
When finished, summarize the code changes and complete the agent run.

This keeps the code execution and the product plan connected. The CLI agent works where the code lives, but Stokik remains where the plan, dependencies, and progress are visible to the team.

Step 6: Let the agent create structured work

You can ask the agent to create a project from a plan:

Use Stokik MCP to create a new project for a billing settings revamp.

Create tasks for:
- payment method management
- invoice history
- tax details
- billing contact
- plan change flow

Create supporting documents for the product spec and rollout notes.
Connect dependencies with labeled edges, especially where one task blocks or feeds another.

The agent can create:

• canvas tasks
• structured Stokik documents from Markdown
• labeled edges between related tasks
• task statuses such as scope, todo, in_progress, done, and backlog

If the agent creates tasks without explicit coordinates, Stokik places them in open canvas slots instead of stacking everything in one place. If the agent creates a project with dependencies, Stokik uses those relationships to place tasks in dependency columns.

Step 7: Track the agent run

Ask the agent to start an agent run before doing meaningful work:

Start a Stokik agent run for this project. As you work, record progress after each major change.

Then ask it to update progress:

Create the missing tasks and documents. Connect dependencies with edge labels.
Record progress as you go, and mark the run complete when finished.

In Stokik, open the project and use the Agents activity control on the canvas. You will see run status and progress events from the external client.

A good working prompt

Here is a prompt that usually produces better results than a vague “make a plan”:

Use Stokik MCP.

Inspect the project first. Read tasks, documents, and edges.
Start an agent run.

Then improve the plan:
- add missing tasks only when they represent distinct work
- create or update supporting documents as structured Markdown
- connect related tasks with labeled edges
- use labels such as blocks, depends on, unblocks, feeds, or clarifies
- avoid deleting anything
- record progress after each major change

When finished, summarize what changed and complete the agent run.

The key is to ask the agent to preserve structure. Stokik is most useful when the project remains a connected model of the work, not just a larger list.

What to use this for

MCP is useful when you want an AI client to work from real project context:

• turning a rough feature idea into tasks and specs
• expanding a project with missing dependencies
• executing a Stokik task from inside a local codebase
• writing rollout notes from the current canvas
• summarizing progress and blockers
• keeping implementation notes attached to the tasks they explain

Stoker remains useful inside Stokik when you want a quick canvas starting point. MCP is useful when you want external tools such as Claude or Codex to participate in the same structured workspace while they operate in the codebase.

Both workflows share the same idea: the plan should stay visible, connected, and current.