two-minds-one-lock
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., "@two-minds-one-lock Use the cipher-lock tools to crack the lock"
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.
Two Minds, One Lock
Two agents. One seeded cipher lock. The same four MCP tools. Does the smarter mind visibly win?
This is a small, honest experiment in legible differential intelligence: a Mastermind-style lock is exposed as an MCP tool surface, and different LLMs take turns trying to crack it under an attempt budget too small to brute-force. The lock is deterministic and seeded, so every mind faces the identical secret. If a stronger model can't visibly out-play a weaker one on the same tools, "bring your own AI" is decoration. It turns out it can.
The result
The graded runs are committed in runs/ and the replay page plays them side by
side:
run | mind | outcome | probes | submits |
| Claude, driven live over MCP | opened | 3 | 1 |
| gemma4:e4b via Ollama | gave up | 3 | 0 |
| gemma4:e4b via Ollama (different seed) | gave up | 3 | 0 |
Claude probed three times, narrowed the code from the ALIGNED/DISPLACED feedback, and committed once - lock open, four attempts to spare. gemma probed without converging and then stopped issuing tool calls entirely. That collapse is itself part of the honest result: a weak model loses on this surface both by reasoning less and by failing to sustain the tool loop.
One caveat worth stating plainly: the Claude run was recorded through the server's transcript log while a live Claude session drove the tools directly (the bring-your-own-AI path below), so it has tool calls but no captured chain-of-thought, and token counts read zero. The gemma runs came through the automated harness.
Watch it:
uv run python -m http.server -d . 8000Then open http://localhost:8000/web/replay.html?seed=42 - it auto-loads both runs from the manifest and steps through them like a match replay.
Related MCP server: ct-mcp
The lock
Four tools, one hostile system:
observe_system()- rules, glyph alphabet, code length, budget, history. Free.probe(approach)- reconnaissance. Returns ALIGNED (right glyph, right slot) and DISPLACED (right glyph, wrong slot). Costs one attempt. Never opens the lock, even on a perfect read.submit_solution(answer)- commit. Opens only on an exact match; a miss costs an attempt and tells you nothing.get_status()- attempts left, locked out, solved.
The budget is far smaller than the search space, so the optimal loop is probe-to-deduce, then submit once confident. When to stop probing and commit is the legible skill.
Crack it with your own Claude (no API key)
The MCP server registers with the Claude you already have. From the repo root:
uv sync
claude # then ask: "Use the cipher-lock tools to crack the lock."Claude Code picks up .mcp.json automatically. The server logs the duel to
runs/claude-42.json as the tools are called, ready for the replay page. For
Claude Desktop, add the server to claude_desktop_config.json with
"command": "uv", "args": ["--directory", "/path/to/two-minds-one-lock", "run", "python", "-m", "tracer", "serve"] and the same env as .mcp.json.
Run the automated duel (needs an API key)
For a repeatable Claude-vs-local-model run without a chat client:
cp .env.example .env # set TRACER_ANTHROPIC_API_KEY; point TRACER_OLLAMA_URL at your Ollama
uv run python -m tracer duel --seed 42This spawns a fresh, identically-seeded MCP server per backend, runs each agent
against it, and writes runs/<backend>-<seed>.json plus a manifest. Knobs:
--seed, --backends claude,gemma (either alone works), and lock difficulty
via TRACER_LOCK_LENGTH / TRACER_LOCK_ALPHABET / TRACER_LOCK_MAX_ATTEMPTS.
Any Ollama model with tool-calling support can play the local seat; swap
TRACER_OLLAMA_MODEL to taste.
Layout
src/tracer/lock.py the seeded, deterministic cipher lock (tested)
src/tracer/server.py FastMCP server exposing the 4 tools over one Lock
src/tracer/agents/ anthropic_agent.py / ollama_agent.py / base.py (shared loop + Recorder)
src/tracer/duel.py stdio-MCP harness: run a backend, record, write runs/
src/tracer/__main__.py serve (subprocess) | duel (harness)
web/replay.html side-by-side transcript replay
tests/test_lock.py the lock logic - a bug here would corrupt the verdict
runs/ the graded evidence the replay auto-loadsTests cover the lock exhaustively because it is the verdict-critical piece; everything else is a thin loop around it.
uv run pytest -qOrigin
Built as the validation tracer for companIAn, a mech game in development at Press Pause Garage where the second player isn't a bot - it's whatever LLM you bring, playing pilot and hacker over MCP while you play gunner. This repo is the experiment that had to pass before the game was worth building. The full write-up: Bring your own AI: building a game where the player's LLM is a teammate over MCP.
License
MIT, (c) 2026 Press Pause Garage LLC.
Available Tools
4 toolsget_statusA
Lightweight check: attempts remaining, whether you are locked out, whether the lock is open, and how many probes/submits you have spent.
Inputs: no named parameters.
observe_systemA
Read the lock before acting: the glyph alphabet, the code length, your remaining attempt budget, the diagnostics legend, and your probe history. Call this first -- it costs nothing.
Inputs: no named parameters.
probeA
Reconnaissance. Test a candidate code -- a string of glyphs from the alphabet, exactly code_length long. Returns ALIGNED (correct glyph in the correct slot) and DISPLACED (correct glyph in the wrong slot) counts. Costs one attempt. A probe NEVER opens the lock; it only gathers information. Probe to deduce the secret.
Inputs: approach (required).
submit_solutionA
Commit to a final answer. Opens the lock if 'answer' is exactly the secret code; otherwise costs one attempt and returns only a rejection -- no diagnostics. Submitting before you have deduced the code wastes the budget. Probe first; submit once confident.
Inputs: answer (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
observe_system and get_status overlap heavily: both report attempts remaining and probe history. While observe_system is more comprehensive, the redundancy could cause an agent to pick the wrong one. probe and submit_solution are clearly distinct.
Most tools follow a verb_noun pattern (observe_system, submit_solution, get_status), but probe is a bare verb without an explicit object. The style is consistent with snake_case lowercase.
Four tools is a well-scoped set for a simple lock-deduction game, covering reconnaissance, probing, solution submission, and status checking.
The tool surface covers the full gameplay loop: observe the system, probe candidates, submit the solution, and check status. No obvious missing operations.
Maintenance
Related MCP Connectors
Reasoning, code, anti-deception, memory harness MCP tools. Stdio or HTTPS api.ejentum.com/mcp
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
MCP-native AI evaluation: rubric audits, eval suites, and proof reports for AI/LLM output.
Stateless agentic tools over MCP: concept extraction, long-context, knowledge graph, planning.
Related MCP Servers
- AlicenseBqualityNot gradedmaintenanceMCP server for structured reasoning with cognitive trap detection, verification, and context compression541 npm1-
- AlicenseAqualityDmaintenanceNine deterministic MCP tools that make LLM answers prove themselves before you trust them.98 npmMIT

Rohan Shieldofficial
AlicenseAqualityBmaintenanceAn in-memory security MCP server for AI agents and coding copilots that prevents sensitive tool parameters and API keys from leaking into LLM context windows. Isolates execution arguments in local RAM using ephemeral cryptographic commitments and deterministic memory zeroization.48MIT- FlicenseNot gradedqualityAmaintenanceEnables LLMs to perform dialectical reasoning (Thesis → Antithesis → Synthesis) and player-coach verified code synthesis through structured MCP tools. It helps catch blind spots and verify requirements by forcing models to argue with themselves before concluding.-