Skip to main content
Glama

Two Minds, One Lock

ci

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

runs/claude-42.json

Claude, driven live over MCP

opened

3

1

runs/gemma-42.json

gemma4:e4b via Ollama

gave up

3

0

runs/gemma-7.json

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 . 8000

Then 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 42

This 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-loads

Tests cover the lock exhaustively because it is the verdict-critical piece; everything else is a thin loop around it.

uv run pytest -q

Origin

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 tools
get_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

    A4.4/5.0

    Scored across 4 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    Four tools is a well-scoped set for a simple lock-deduction game, covering reconnaissance, probing, solution submission, and status checking.

    Completeness5/5

    The tool surface covers the full gameplay loop: observe the system, probe candidates, submit the solution, and check status. No obvious missing operations.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Nine deterministic MCP tools that make LLM answers prove themselves before you trust them.
      9
      8 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      An 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.
      4
      8
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables 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.
      -