Run 3 Agents in Parallel With Momental in 20 Minutes

Most people run Claude Code agents sequentially. One terminal window, one task at a time, wait for it to finish, then start the next one.

There’s a good reason for this: running multiple agents in parallel without shared context creates coordination problems. Agents contradict each other, duplicate work, or make assumptions that conflict. Sequential is slower but safer.

This tutorial shows you how to run agents in parallel without those coordination problems — using Momental as the shared context layer that keeps all three agents aligned.

By the end, you’ll have three Claude Code sessions running simultaneously on different tasks, with each agent able to see what the others are doing.

What You’ll Need

• Claude Code installed and working
• A Momental account (momentalos.com — free to start)
• Three terminal windows (or tabs)
• About 20 minutes

Why This Matters

The productivity ceiling with sequential agents is limited by how fast one agent can work. With parallel agents, three workstreams advance simultaneously.

The catch: parallel agents in isolation create the coordination failures described in stop agents losing context. The fix is a shared context layer — which is exactly what this setup provides.

Step 1 — Connect Claude Code to Momental via MCP (5 minutes)

MCP (Model Context Protocol) is how Claude Code connects to external tools and data sources. Momental runs as an MCP server that gives Claude Code access to the shared knowledge graph and task system.

Get your MCP connection details.

Log into Momental and go to Connections → add Claude Code (under “Your connections”). You’ll see an MCP server URL and an API key.

Add the Momental MCP server to your Claude Code config.

In your project’s CLAUDE.md file (or your global ~/.claude/CLAUDE.md), add the MCP configuration. It looks like this:

# MCP Servers
Connect to Momental at https://mcp.momentalos.com/mcp/v3 using your API key.

The exact format depends on your Claude Code version. The Momental settings page shows the current recommended snippet — copy it directly from there.

Verify the connection.

Open a Claude Code terminal and ask it to call whoami via the Momental MCP tools. If the connection is working, it’ll return your identity and any assigned tasks. If it fails, check that the API key is correct and the MCP server URL matches what’s in your Momental settings.

Step 2 — Create Your First Task in Momental (3 minutes)

You can create tasks from Claude Code itself, but for this tutorial let’s create them from the Momental web UI first so you can see what’s happening.

Open Momental and create a goal.

In the Plans view, create a new objective. Something like “Ship v1.2 billing reliability improvements.” This becomes the parent that your tasks will connect to.

Create three tasks under that goal.

• Task 1: “Fix race condition in payment webhook handler”
• Task 2: “Add retry logic to failed charge queue”
• Task 3: “Write integration tests for payment flow”

Each task should have enough context in the description that an agent can start working without additional briefing. Be specific about what done looks like.

Set task status to “Ready” for all three.

This signals to agents that these tasks can be picked up.

Step 3 — Assign the First Task to an Agent (2 minutes)

Open your first terminal window with Claude Code.

Ask the agent to check its assigned tasks:

Check Momental for my assigned tasks and start on the highest priority one.

The agent will:

1. Call whoami to get its identity and assigned tasks
2. Call work_begin on the highest-priority ready task
3. Return a brief showing the task, acceptance criteria, and any relevant context from the knowledge graph

You’ll see it acknowledge which task it’s starting, what it’s about to do, and any relevant prior decisions or learnings from the graph.

Let it start working. Leave this terminal window running.

Step 4 — Create Two More Agent Sessions (3 minutes)

Open two more terminal windows.

In the second terminal, tell Claude Code to pick up a different task:

Check Momental for unassigned tasks and claim one. Do not pick up the task that Agent 1 already has.

The agent will query Momental, see what’s already claimed (by the first agent), and pick one of the remaining tasks.

Do the same in the third terminal window.

Now you have three Claude Code sessions, each working on a different task, each connected to the same Momental knowledge graph.

Step 5 — Watch Agents Coordinate (while you do something else)

This is the part that’s worth watching for a few minutes before you step away.

What you’ll see in each terminal:

Agents periodically write checkpoints to their tasks. They surface decisions they made. They note blockers. If one agent discovers something that affects another task, it writes a note to the shared graph.

What the Momental dashboard shows:

All three tasks update in real time. You can see which agent is on which task, what they’ve done, and what their current status is. No manual updates required.

What coordination looks like:

If agent 2 is working on the retry logic and notices something about the payment webhook handler that agent 1 should know, it writes a note to the shared graph. Agent 1, on its next checkpoint, will see this context and can adjust.

This is the visible difference between parallel agents with coordination vs. parallel agents in isolation.

What Shared Context Looks Like

The Momental knowledge graph all three agents are reading and writing to contains:

Task state. Each agent’s task is live — status, progress notes, decisions made, blockers flagged. All three agents can see all three tasks.

Code claims. When an agent starts working on a file, it records a claim in the graph. Other agents can see what files are actively being edited. If two tasks involve the same file, the agents know before there’s a conflict.

Decisions. When agent 1 decides to handle the webhook race condition a particular way, it writes a DECISION atom. Agent 3, writing integration tests, reads that decision and writes tests that align with it — not tests that assume a different approach.

Findings. When any agent discovers something useful — a quirk in the payment processor’s API, a specific error code that needs special handling — it writes a LEARNING atom. The other agents have access to this immediately.

Troubleshooting

“Agent says it has no context.” Check the MCP connection. Call whoami and see if it returns your Momental identity. If the connection is broken, the agent will start from zero.

“Agents are doing duplicate work.” This usually means agents aren’t using the task assignment system. Each task should have an explicit owner. If an agent picks up work that isn’t assigned to it, it’ll work in isolation without checking if someone else already started.

“Agents are making conflicting decisions.” This is the coordination failure mode. Check whether both agents are connected to Momental. If they’re connected but still conflicting, look at the DECISION atoms — the newer one takes precedence, but you may need to add a note in the shared graph clarifying the intended approach.

“One agent is blocking another.” Check the file claims in Momental. If agent 1 has claimed a file that agent 2 needs, they’ll both see this and one can wait or coordinate via task comments.

---

Running agents in parallel multiplies output. Running them with shared context makes that output coherent. Momental handles the coordination layer so you don’t have to.

→ From the author

Want an AI team that actually ships?

Momental gives your agents shared memory, strategy context, and coordination — so they work like a full product team. No more one-shot prompts.

Get started →Book a demo