conductor
Conductor is an MCP server exposing 23 contract-verified tools for text/data processing and model-backed language tasks.
Run deterministic, code-only tools for slugs, word counts, phone normalization, truncation, line deduplication, URL/email extraction, template filling, base64, JSON minification, and snake_case conversion.
Run model-backed tools for contact extraction, summaries, keywords, sentiment classification, PII redaction, JSON extraction/repair, date extraction, categorization, translation, and language detection.
Rely on mandatory verifiers that check schemas, recomputation, grounding, and output shape, with retries or fallbacks on failure.
Receive consistent result envelopes with
ok,output,via,attempts, andverdictfeedback.Use it as a Claude Code plugin, via
npx, from a cloned stdio MCP server, or through its CLI for testing, pipelines, routing, and telemetry.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@conductor extract contact from this email: 'John Doe, john@example.com, (555) 123-4567'"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
conductor
Verified tool calls for Claude Code: an MCP server (installable as a plugin) whose 23 tools check their own output in code before you get it.
A model asked to "extract the email" or "redact the phone numbers" is usually right, and nothing
tells you when it isn't. conductor puts each job behind a contract: an input schema, an output
schema and a mandatory verifier. Deterministic jobs (slugs, base64, URL extraction) run as plain
code and never touch a model. Judgment jobs (summaries, PII redaction) run as hermetic claude -p
calls, and an answer that fails its verifier is retried with the failure as feedback, handed to a
fallback, or returned as a failure; it is never silently passed through.
The skeleton (validate -> execute -> verify -> retry -> fallback -> log) is real code that cannot be skipped; the model is quarantined to the judgment-shaped holes.
Quick start
You need Claude Code installed and logged in, and Node.js
20 or newer on your PATH (the plugin starts the server with node).
claude plugin marketplace add fainir/conductor
claude plugin install conductor@conductorRestart Claude Code (or run /reload-plugins in a running session). Inside a session the same
steps are /plugin marketplace add fainir/conductor and /plugin install conductor@conductor.
Check that the server is up:
$ claude mcp list
plugin:conductor:conductor: node /Users/you/.claude/plugins/cache/conductor/conductor/0.4.1/dist/conductor-mcp.cjs - ✓ ConnectedTry this first in Claude Code:
Use Conductor's slugify tool to turn
Hello, World!into a URL slug.
Look for hello-world and verdict.ok: true in the tool result. The slugify tool runs as code. In a plugin install its name is
mcp__plugin_conductor_conductor__slugify.
Update with claude plugin marketplace update conductor && claude plugin update conductor@conductor,
remove with claude plugin uninstall conductor@conductor.
Without the plugin system. dist/conductor-mcp.cjs is a committed, self-contained bundle, so
a clone needs no install or build step:
git clone https://github.com/fainir/conductor
claude mcp add conductor -s user -- node "$PWD/conductor/dist/conductor-mcp.cjs"Other MCP clients can run npx -y @fainir/conductor, which serves MCP over stdio. The unrelated
conductor-mcp package on npm belongs to someone else.
Related MCP server: claude-work-mcp
Usage
Every tool returns the same envelope. Real output from the bundle for base64_encode with
{"text": "hello"}:
{ "ok": true, "output": { "encoded": "aGVsbG8=" }, "via": "base64_encode", "attempts": 1, "verdict": { "ok": true, "score": 1 } }via names the rung that produced the answer (the tool itself, a declared fallback, or
freeform for plain Claude), and attempts counts tries on that rung. A failure sets ok: false
and the tool result's isError, and the verdict says why, so the calling model can fix its call:
{ "ok": false, "via": "redact_pii", "attempts": 0,
"verdict": { "ok": false, "score": 0, "feedback": "invalid input: input: missing required property 'text'; input: unexpected property 'txt' (allowed: text)" } }From a clone you can drive the same loop with the CLI (npm ci first). Pure tools answer
instantly and cost nothing:
$ npx tsx src/cli.ts slugify '{"text":"Hello, World!"}'
{
"ok": true,
"output": {
"slug": "hello-world"
},
"command": "slugify",
"attempts": 1,
"verdict": {
"ok": true,
"score": 1
},
"costUsd": 0
}
$ npx tsx src/cli.ts normalize_phone '{"phone":"call me"}'
{
"ok": false,
"command": "normalize_phone",
"attempts": 1,
"verdict": {
"ok": false,
"score": 0,
"feedback": "shape: normalized must match /^\\+?\\d{6,15}$/ (an optional leading '+' followed by 6-15 digits)"
},
"costUsd": 0
}The CLI exits 1 when the result fails verification. Model-backed tools work the same way
(npx tsx src/cli.ts extract_contact '{"text":"Call Sam at sam@acme.io"}') and spend a
claude -p call per attempt. npx tsx src/cli.ts with no arguments lists the commands, and
npx tsx src/cli.ts route "make a url slug" '{"text":"Hello World"}' lets a model pick the command.
Tools
Pure tools (code only, no model call)
tool | input | what it does | verifier checks |
|
| Convert a string into a URL-safe slug. | non-empty; only |
|
| Count the words and characters in a string. Words are whitespace-separated tokens of the trimmed text; chars is the raw length of the input. | recomputes both counts |
|
| Normalize a phone string to canonical '[+]digits' form by stripping non-digit characters. | recomputes; optional |
|
| Truncate text to at most | length never exceeds |
|
| Split text on newlines and keep the first occurrence of each line, preserving order. | no duplicates; every line comes from the input; recomputes |
|
| Extract all http(s) URLs from a text, deduped while preserving first-seen order. | http(s) shape; each URL appears in the input |
|
| Fill a template by replacing every {{key}} token with String(data[key]); fails, naming the keys, if any {{key}} has no value in data. | recomputes; no |
|
| Encode a UTF-8 string to base64. | decodes back to the input |
|
| Decode a base64 string to UTF-8 text. | re-encodes to the input (padding and line breaks ignored) |
|
| Extract all email addresses from text. | email shape; each address appears in the input |
|
| Minify a JSON string by removing insignificant whitespace. | parses to the same value as the input |
|
| Convert a string to snake_case. | recomputes |
Model-backed tools (hermetic claude -p call)
tool | input | what it does | verifier checks |
|
| Extract a contact's name, email, and phone from a blob of text. | schema; email and phone shape; the email must appear in the input (grounding) |
|
| Summarize a blob of text in at most a few sentences, using only the text itself. | at most |
|
| Extract up to k salient keywords or short phrases that appear verbatim in the input text. | 1 to |
|
| Classify the overall sentiment of a piece of text as positive, negative, or neutral. | label is one of the three; confidence in 0..1 |
|
| Replace every email address and phone number in the input text with [REDACTED], leaving all other text unchanged. | no email or phone pattern left; |
|
| Extract a caller-specified list of fields from a blob of text into a JSON object. Each requested field becomes a key; the value is null when the field is absent from the text. |
|
|
| Repair malformed or loosely-formatted JSON text into a valid JSON value. |
|
|
| Extract every date referenced in a piece of text, normalized to ISO format YYYY-MM-DD. | each is a real calendar date in |
|
| Choose the single best-fitting category for a piece of text from a provided list of categories. | exactly one of the given categories |
|
| Translate a piece of text into a given target language. | non-empty; at most 5x the input length + 20 |
|
| Detect the natural language of text. | non-empty name; two-letter lowercase ISO 639-1 code |
Inputs ending in ? are optional. The first three columns come from the command manifests
(npm test fails if they drift); the full JSON Schemas are what the MCP server advertises.
How it works
input -> inputSchema check -> run the command -> verify -> ok? -> result
^ | no
+-- retry with the verifier's feedback (model-backed, up to maxAttempts)
| still no
declared fallbacks -> freeform (plain Claude, same schema, same verifier)Contracts with mandatory verifiers. Each command is
commands/<name>/index.ts: a manifest (input and output JSON Schema, determinism, prompts, fallbacks) plus averify()export. A command without a verifier cannot be registered (src/library.ts,src/registry.ts). Mechanical checks come first (schema, regex, recompute, grounding);llmJudgeinsrc/verify.tsexists for criteria no code can express.Precondition gate. Input that breaks the command's
inputSchemais rejected before anything runs, with a message that names the problem.Determinism gradient.
purecommands are deterministic code: run once, cached, free, and never sent to a model.stochasticcommands are run by the model and retried with feedback.effectfulis reserved for commands that will need a human gate.Fallback to freeform. Every model-backed ladder ends at plain Claude, held to the same output schema and verifier, so the conductor never does worse than a raw call, only better when a verified command applies.
Hermetic calls. Every model call (
src/cc.ts) replaces the system prompt (--system-prompt), loads no settings (--setting-sources ""), enables no tools (--tools ""), saves no session, and constrains the answer with--json-schema. This matters: a naive call once returned the operator's own email instead of the one in the input, because ambient context (global CLAUDE.md, identity, hooks) leaked in.Composition.
runPipeline(src/pipeline.ts) chains commands; each step is verified before the next runs, so errors cannot silently compound.Telemetry and routing. Every attempt is a JSONL line.
npm run scoresprints per-command reliability from the CLI and eval logs, androute()(src/router.ts) shows those rates to a small model that must pick from an enum of command names.
Configuration
Setting | Default | Effect |
|
| Where the MCP server appends |
|
| Model for that command's calls (the router and |
|
| Tries with feedback before the next fallback rung (pure commands run once) |
Model-backed calls use whatever account the claude CLI is logged into.
Results (measured by the author)
Evals compare a single naive claude -p call with the conductor on the same inputs:
Single-shot extraction (
eval/run-eval.ts): baseline 100% vs conductor 100%. On easy single-shot tasks a frontier model is already reliable, so there is no gap to close.Composition (
eval/contact-card.ts, extract_contact -> normalize_phone -> slugify): baseline 80% vs conductor 100%. The baseline emitted a phone number with an invisible Unicode character; the deterministicnormalize_phonestep is structurally immune to that class of error. Cost: the conductor made more calls, about 2x the baseline.
The reliability gap grows with composition depth and machine-consumed output, not with single easy
calls. The evals call claude and cost money; rerun them with REPEATS=2 npx tsx eval/run-eval.ts,
REPEATS=2 npx tsx eval/contact-card.ts and REPEATS=1 npx tsx eval/triage.ts (a 4-step pipeline).
Add a command
Create
commands/<name>/index.ts. A pure command exportsmanifest,runandverify:import type { CommandManifest, SolveContext, Verdict } from "../../src/types.js"; import { check, combine } from "../../src/verify.js"; export const manifest: CommandManifest = { name: "reverse_text", // must equal the directory name description: "Reverse the characters of a string.", determinism: "pure", trust: "human-verified", inputSchema: { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false }, outputSchema: { type: "object", properties: { reversed: { type: "string" } }, required: ["reversed"], additionalProperties: false }, fallbacks: [], effectful: false, }; export async function run(input: { text: string }): Promise<{ reversed: string }> { return { reversed: [...input.text].reverse().join("") }; } export async function verify(output: { reversed: string }, input: { text: string }, _ctx: SolveContext): Promise<Verdict> { return combine( check("string", typeof output?.reversed === "string", "reversed must be a string"), check("round-trip", [...(output?.reversed ?? "")].reverse().join("") === input.text, "reversing the output must give the input back"), ); }A model-backed command sets
determinism: "stochastic", leaves outrun, and addssystemPrompt,promptTemplate,model,maxAttemptsandfallbacks: ["freeform"]; itsverifychecks the model's answer (seecommands/extract_contact/index.ts).Add
commands/<name>/tests/cases.json, a list of{ "input": ..., "expect"?: ... }.Import the module in
src/library.tsand add it toMODULES(the bundle cannot scan directories).Add a row to the right table above.
npm testchecks contracts, runs pure commands against their cases, and prints the exact README row it expects.npm run buildand commitdist/conductor-mcp.cjs, which is what the plugin runs.
Development
npm ci
npm test # hermetic: a fake `claude` on PATH, no model calls, no network
npm run typecheck
npm run build # rebuild dist/conductor-mcp.cjs and commit it (CI fails if it is stale)
npm run mcp # run the server from source over stdio
npm run scores # reliability scoreboard from projects/*/telemetry.jsonl
# These call the real claude CLI and cost money:
npx tsx eval/run-tests.ts [command] # each command's tests/cases.json through the full loop
npm run eval # eval/run-eval.tsnpm run release [patch|minor|major] bumps the version in package.json and both plugin
manifests, rebuilds, commits and pushes; installed users then get it from
claude plugin update conductor@conductor.
src/
mcp.ts MCP server: one tool per command, every call through solve()
solve.ts the loop: input check -> execute -> verify -> retry -> fallback
schema.ts the JSON Schema subset used by command contracts
cc.ts one hermetic `claude -p` call
verify.ts verifier helpers: check/combine, zod schema, email/phone patterns, llmJudge
pipeline.ts compose verified commands
router.ts reliability-weighted command choice
telemetry.ts JSONL log + per-command scores
library.ts static command list (what the bundle ships)
registry.ts directory scan used by the CLI and evals
cli.ts manual driver
scores.ts prints the scoreboard
commands/<name>/ index.ts (manifest + run? + verify) and tests/cases.json
eval/ baseline-vs-conductor evals (paid)
test/ node:test suite (free)
dist/ committed bundle the plugin runsLimitations and FAQ
Model-backed tools need the
claudeCLI logged in, and each attempt is a separateclaude -pprocess, so expect seconds per call and usage on your account. Pure tools need neither.Verifiers are mechanical. They catch format, grounding and budget violations, not every semantic error:
categorizecan pick an allowed but wrong category, and a summary can be within budget and still miss the point. No shipped command usesllmJudgeyet.Some detectors are heuristics.
redact_piitreats any long run of digits and separators as a phone number, so ISO dates or order numbers in the output fail the check and may get redacted on retry.summarizecounts sentences by.,!and?, so abbreviations count.Telemetry stays on your machine (
~/.conductor/telemetry.jsonlfor the MCP server,projects/for the CLI and evals). Inputs go nowhere except theclaude -pcalls themselves.Opening this repo as a Claude Code project shows a failed
conductorserver from.mcp.json;${CLAUDE_PLUGIN_ROOT}only expands in an installed plugin. That is harmless.Not built yet: model-driven decomposition (pipelines are explicit), human gates for
effectfulcommands, routing inside the MCP server (the client model picks tools itself), turning traces into new commands, and RL on the router.
License
More open source by Nir Feinstein
agent-harness - make Claude Code or Codex act as a product team, a CEO or a portfolio manager
frugal - your agent finds the cheaper honest way before it pays for anything
flipback - an automatic
/goalfor every turn: sends Claude Code back when it stops earlyrecall - your Claude Code memory in every agent, over MCP
Available Tools
23 toolsbase64_decodeC
Decode a base64 string to UTF-8 text. [conductor: verified pure command]
Inputs: encoded (required).
base64_encodeA
Encode a UTF-8 string to base64. [conductor: verified pure command]
Inputs: text (required).
categorizeB
Choose the single best-fitting category for a piece of text from a provided list of categories. [conductor: verified stochastic command]
Inputs: text (required), categories (required).
classify_sentimentC
Classify the overall sentiment of a piece of text as positive, negative, or neutral. [conductor: verified stochastic command]
Inputs: text (required).
dedupe_linesA
Split text on newlines and keep the first occurrence of each line, preserving order. [conductor: verified pure command]
Inputs: text (required).
detect_languageC
Detect the natural language of text. [conductor: verified stochastic command]
Inputs: text (required).
extract_contactC
Extract a contact's name, email, and phone from a blob of text. [conductor: verified stochastic command]
Inputs: text (required).
extract_datesB
Extract every date referenced in a piece of text, normalized to ISO format YYYY-MM-DD. [conductor: verified stochastic command]
Inputs: text (required).
extract_emailsC
Extract all email addresses from text. [conductor: verified pure command]
Inputs: text (required).
extract_keywordsB
Extract up to k salient keywords or short phrases that appear verbatim in the input text. [conductor: verified stochastic command]
Inputs: text (required), k.
extract_urlsA
Extract all http(s) URLs from a text, deduped while preserving first-seen order. [conductor: verified pure command]
Inputs: text (required).
fix_jsonC
Repair malformed or loosely-formatted JSON text into a valid JSON value. [conductor: verified stochastic command]
Inputs: text (required).
json_extractC
Extract a caller-specified list of fields from a blob of text into a JSON object. Each requested field becomes a key; the value is null when the field is absent from the text. [conductor: verified stochastic command]
Inputs: text (required), fields (required).
json_minifyB
Minify a JSON string by removing insignificant whitespace. [conductor: verified pure command]
Inputs: json (required).
normalize_phoneA
Normalize a phone string to canonical '[+]digits' form by stripping non-digit characters. [conductor: verified pure command]
Inputs: phone (required).
redact_piiA
Replace every email address and phone number in the input text with [REDACTED], leaving all other text unchanged. [conductor: verified stochastic command]
Inputs: text (required).
slugifyB
Convert a string into a URL-safe slug. [conductor: verified pure command]
Inputs: text (required).
summarizeC
Summarize a blob of text in at most a few sentences, using only the text itself. [conductor: verified stochastic command]
Inputs: text (required), max_sentences.
template_fillA
Fill a template by replacing every {{key}} token with String(data[key]); fails, naming the keys, if any {{key}} has no value in data. [conductor: verified pure command]
Inputs: data (required), template (required).
to_snake_caseB
Convert a string to snake_case. [conductor: verified pure command]
Inputs: text (required).
translateC
Translate a piece of text into a given target language. [conductor: verified stochastic command]
Inputs: text (required), target_language (required).
truncateA
Truncate text to at most max characters, appending a single-character ellipsis when it must be cut. [conductor: verified pure command]
Inputs: max (required), text (required).
word_countA
Count the words and characters in a string. Words are whitespace-separated tokens of the trimmed text; chars is the raw length of the input. [conductor: verified pure command]
Inputs: text (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 23 tools
Most tools have clearly distinct purposes, but a few boundaries are slightly fuzzy: extract_contact overlaps with extract_emails/redact_pii, slugify overlaps with to_snake_case, and classify_sentiment overlaps with categorize. The descriptions generally clarify the distinctions, so misselection risk is low but not zero.
All names use consistent snake_case, which is a strong baseline. However, the convention mixes verb_noun (extract_emails, normalize_phone), noun_verb (word_count, json_extract, base64_encode), and bare verbs (summarize, truncate, translate), which is a minor inconsistency.
At 23 tools, the set is heavy for a text-processing utility server and sits at the upper edge of the appropriate range. Each tool is small and focused, but the overall surface feels broad rather than tightly scoped.
The server covers a wide range of text operations: normalization, extraction, transformation, classification, translation, encoding, and JSON repair/minification. Some generic utilities like regex replace, case conversion beyond snake_case, or HTML stripping are missing, but the core workflows are well supported.
Maintenance
Related MCP Connectors
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Hosted Web Crawler MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Related MCP Servers
- AlicenseAqualityDmaintenanceA safe, local MCP server that lets Claude drive a controlled software-development loop (inspect, read, plan, patch, apply, check, analyze, fix, summarize) on a project, using deterministic tools and real diffs/test runs.101MIT
- FlicenseNot gradedqualityDmaintenanceA local MCP server that connects Claude Code to your work environment through auditable tools for file operations, API calls, and command execution, with safety gates and configuration.-
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enhances Claude Code with evidence-first engineering, protocol gates, project-aware verification, auditable traces, and durable autonomous execution.15 npmMIT
- AlicenseNot gradedqualityDmaintenanceMCP server that turns coding workflows into explicit execution graphs (DAG) with deterministic command execution, human-in-the-loop gates, and tamper-proof run history for Claude Code.3 npmMIT