Mechanoscope

An AI research copilot for controlled, replayable interpretability experiments on open-weight language models.

Comment

Inspiration

Language models produce answers in seconds, but investigating how those answers formed still means stitching together research repositories, notebooks, GPU jobs, and disconnected visualizations. We wanted interpretability to feel less like a collection of demos and more like a careful scientific workflow.

Mechanoscope is an open-source observatory for open-weight language models. It helps a researcher state a hypothesis, plan a controlled experiment, inspect internal representations, intervene on the model, preserve the results, and understand what the evidence does—and does not—support.

What it does

Mechanoscope currently provides two real interpretability instruments:

  • Jacobian Lens shows how small changes at intermediate layers influence the model's final representation. Its linked 2D and 3D views let researchers follow token-like predictions across layers and prompt positions.
  • Activation Steering constructs a contrastive residual-stream direction and compares a matched baseline with an intervention using the same prompt, seed, and generation settings.

Every run becomes a durable experiment receipt containing the prompt, model revision, technique revision, parameters, controls, outputs, timing, and provenance. Receipts can be replayed, forked, compared, shared, or exported.

The most important feature is Claim Check. Two experiments using the same model and prompt may be comparable parallel evidence, but that does not automatically establish a causal relationship. Mechanoscope explicitly reports supported conclusions, incompatibilities, and claims the evidence cannot prove.

The GPT-5.6 research copilot

A researcher can state a falsifiable hypothesis in ChatGPT. GPT-5.6 uses Mechanoscope's typed MCP tools to:

  1. discover available models and instruments;
  2. construct a controlled, digest-pinned experiment plan;
  3. show the exact requests, controls, cost boundary, and limitations;
  4. request explicit approval before GPU compute;
  5. run the unchanged plan;
  6. inspect both durable receipts; and
  7. explain the evidence boundary.

Planning is read-only. GPU execution is refused until the researcher approves the exact plan digest, so the model cannot silently change the experiment or spend compute.

How we built it

The React and TypeScript frontend contains purpose-built 2D instruments and a React Three Fiber representation volume. FastAPI provides typed experiment contracts, model and technique registries, receipt persistence, replay, fork, and comparison. PyTorch runs the scientific techniques on on-demand Modal GPUs, so model weights are never downloaded to the browser or developer machine. A streamable HTTP MCP server exposes the same research workflow to ChatGPT.

OpenAI Codex was our engineering collaborator throughout the build, not just a scaffolding tool. Codex helped research the source techniques and current documentation, design the modular runtime and experiment architecture, implement backend and frontend slices, integrate MCP, write regression tests, diagnose remote GPU failures, refine the interface, verify scientific guardrails, and deploy the live system.

GPT-5.6 is part of the product itself. It is the reasoning layer that converts natural-language hypotheses into typed research plans and explains the structured evidence returned by Mechanoscope.

Challenges

The hardest challenge was preserving scientific honesty while making advanced interpretability approachable. Jacobian Lens observation and activation steering intervention can share a model and prompt without sharing representation lineage. It would be visually tempting—but scientifically wrong—to imply one caused the other. We designed the experiment record and Claim Check around preventing that mistake.

Remote model loading, fitted-lens revisions, hook cleanup, reproducible sampling, GPU lifecycle management, generated Python/TypeScript contracts, and synchronized 2D/3D selections also required careful separation of concerns.

What we learned

Interpretability needs more than better visualizations. It needs provenance, controls, negative results, and explicit limits. A failed steering run can be more valuable than a cherry-picked success when the system preserves it honestly.

We also learned that an AI research copilot is most useful when it is constrained by typed tools and human checkpoints. GPT-5.6 provides flexible reasoning; Mechanoscope remains authoritative for execution, receipts, compatibility, and evidence.

What's next

We plan to add more observation, intervention, and evaluation instruments behind the same experiment interface; derive steering interventions directly from selected representations; support larger open models; add collaborative receipt collections; and build automated sensitivity sweeps over layers, strengths, and prompts.

Because seeing a pattern is easy. Knowing what the experiment actually proved is the hard part.

Built With

Share this project:

Updates