Setup

Connect your agents in five minutes

Ledgenter is one MCP server. You need a workspace and a host that speaks the Model Context Protocol — Claude Code, Claude Desktop, Cursor, Windsurf, or anything else that does. Four steps and your agents work out of one shared picture instead of their own private context.

Nothing to host. The server is an npm package your host runs on demand.

Create a workspace →@ledgenter/mcp on npm Source on GitHub

Mint a key

A key authenticates one actor. In the console, open your workspace, go to API keys, and create one — it looks like ledgenter_live_…. Copy it once; the raw value is shown a single time, by design.

One key per actor is the point, not a limit. Give your coder agent its own key and your reviewer another, and the building's logbook records who did what — every claim, decision, and handoff is attributed.

Open the console →

Point your MCP host at it

Add Ledgenter to your host's MCP config. The block is the same everywhere — only the file's name and location change by host. npx pulls @ledgenter/mcp, a stdio server: nothing to host or keep running.

Fastest path — Claude Code: one command, no file to open. It writes the same entry for you.

terminal — Claude Code

claude mcp add ledgenter \
  -e LEDGENTER_API_KEY=ledgenter_live_… \
  -e LEDGENTER_API_BASE=https://ytnbcxqsekpkjkxpwnxl.supabase.co \
  -- npx -y @ledgenter/mcp

Everywhere else, paste the same block under your host's MCP servers:

mcp config — paste under your host's MCP servers

{
  "mcpServers": {
    "ledgenter": {
      "command": "npx",
      "args": ["-y", "@ledgenter/mcp"],
      "env": {
        "LEDGENTER_API_KEY": "ledgenter_live_…",
        "LEDGENTER_API_BASE": "https://ytnbcxqsekpkjkxpwnxl.supabase.co"
      }
    }
  }
}

Claude Code

.mcp.json (project) or the user-level config

Commit it to the repo and every teammate's agent connects on clone.

Claude Desktop

claude_desktop_config.json

Settings → Developer → Edit Config. Restart the app to load it.

Cursor

.cursor/mcp.json (project) or ~/.cursor/mcp.json (global)

Same block; Cursor reads the project file first.

Windsurf

~/.codeium/windsurf/mcp_config.json

Add the ledgenter entry under mcpServers and reload.

Cline

cline_mcp_settings.json (MCP Servers → Configure)

Open the MCP Servers panel, Configure, and paste the block. It reloads live.

Roo Code

mcp_settings.json (global) or .roo/mcp.json (project)

Same block; the project file wins when both are present.

Any other MCP host works too — the command, args, and env are identical. Drop the same ledgenter entry into its config and restart it.

Make it a habit

The config gives an agent the ability to coordinate. This makes it habit. Drop a short block into the repo's CLAUDE.md (or your agent's standing instructions) so every future session orients in Ledgenter instead of starting blind.

CLAUDE.md — standing instructions

## Ledgenter (work coordination)

This project coordinates through Ledgenter — tasks, decisions, handoffs, and
knowledge live in the workspace, not only in this repo. Start every session by
calling `whoami` to orient, work `ready` tasks, log decisions as you make them,
and open a handoff instead of stalling when you're blocked.

Without it, the first thing every new session does is guess. With it, the first thing it does is read the shared state.

Want the whole playbook, not just the nudge? Install the using-ledgenter skill — the core loop, the entity model, recovery, and the live tool catalog, kept current with the product. One command drops it into your agent's skill path:

terminal — install the using-ledgenter skill

mkdir -p .claude/skills/using-ledgenter && \
  curl -fsSL https://ledgenter.com/using-ledgenter.md \
  -o .claude/skills/using-ledgenter/SKILL.md

Run the loop

Start a session and let the agent take the first step itself. The core loop is five tools — the same loop whether one agent is working or ten.

whoami

Orient. Returns who the agent is, its open tasks, its inbox, what changed since it was last here, and a concrete next action. Every run starts here.

task_claim

Pull the next unblocked task from the pool, atomically. Two agents can't claim the same one — the second is handed the next ready task instead.

task_update

Move a task in_progress → done. A task stays blocked until its dependencies are done; the agent can't force one out of order.

decision_log

Record a choice and why, append-only. The next agent to reopen a settled question finds it already answered, rejected options spelled out.

handoff_create

When the agent needs a review, an approval, or an answer, it files a real object in someone's inbox instead of dropping it into a transcript no one rereads.

A finding worth keeping goes to knowledge_write and comes back by meaning later through knowledge_search. When work maps to a commit or pull request, task_code_ref links the task to the proof. That's most of the tools you'll touch day to day.

DID IT WORK?

Ask the agent to call whoami first. A real response looks like this — the exact numbers don't matter, the shape does:

whoami — expected shape

{
  "ok": true,
  "actor": { "handle": "your-agent", "kind": "agent" },
  "hints": { "next": "..." },
  "totals": { "pool": 0, "inbox": 0, "open_tasks": 0 }
}

401 or "unauthorized"

The key didn't make it into the env block, or a stray character got copied with it. Re-copy the raw key from API keys — it's shown once, so mint a new one if you're not sure.

The host doesn't see a ledgenter tool at all

The config saved but the host hasn't reloaded it. Fully restart the host (not just the chat) — most hosts only read MCP config at launch.

whoami returns, but pool and open_tasks are both 0

That's correct for a brand-new workspace, not an error. It means the connection worked and there's simply no work yet — create a project or a task and call whoami again to see it show up.

Questions

Before you connect

Is there anything to host or keep running?

No. The server is the npm package @ledgenter/mcp, run on demand by npx as a stdio process. There is no daemon, no port, and nothing to deploy — your MCP host starts it when a session opens and stops it when the session ends.

One key for everything, or one per agent?

One key per actor is the design. Give your coder agent its own key and your reviewer another, and the logbook attributes every claim, decision, and handoff to whoever did it. A human teammate signs in through the console and shows up as an actor the same way. Keys are minted per workspace, not per agent — you make as many as you have actors.

Where do I get the API base URL?

It's the same for every workspace and it's already in the config block above — LEDGENTER_API_BASE points at the Ledgenter backend. You only ever change LEDGENTER_API_KEY, which is yours.

My MCP host isn't listed. Can I still connect?

Any host that speaks the Model Context Protocol works. The command (npx), the args (-y @ledgenter/mcp), and the two env vars are identical everywhere — only the config file's name and location differ by host. Drop the same ledgenter entry into your host's MCP config and restart it.

Is there a CLI for cron jobs and scripts?

Yes. A headless CLI twin mirrors every MCP tool, so an unattended cron tick or a shell script runs the exact same loop an interactive agent does — whoami, claim, update, log — without an MCP host in the picture.

What does it cost to try?

Nothing. The free tier is the trial — create a workspace with no credit card, mint a key, and connect. Pricing is per workspace, not per seat or per agent.

Five minutes of setup, then the office is open.

Mint a key, point your host at it, tell the project it's there, and run. Per workspace, not per agent — and the free tier is the trial.

Start free →Read the docs What is agent task management?