Skip to main content
AIDiveForge AIDiveForge
Save tools:Log inSign up
Visit Subtext

Get This Tool

License: Apache-2.0 Any use incl. commercial
Local-run terms: Users may run, modify, and distribute the code under Apache 2.0 terms for any purpose including commercial use.

Share This Tool

Compare This Tool
📋 Embed this tool on your site

Copy this code to embed a compact tool card:

Screenshots 5

Subtext

FreeOpen SourceSelf-Hosted

Pricing

Model
Free

Summary

You set a breakpoint, you read the logits, you stare at the output — and you still have no idea what the model was 'thinking' between prompt and token. Subtext exists for that gap.

Subtext is an open-source, self-hosted tool that surfaces a local language model's internal representations — specifically the J-space global workspace identified in Anthropic research — as the model reads and generates, before output tokens appear. You get a browser-based live view and the ability to record, export, and replay sessions for later analysis. The stack is Python-based and runs against local models, so there is no cloud dependency and no data leaves the machine. The ceiling appears quickly: Subtext has no API, no integration hooks, and no support for models it cannot instrument directly — which means anything running behind a remote endpoint stays opaque.

Bottom line: Pick this if you are a researcher or developer running local models and want to see internal states that logs will never show you — but plan a different approach the moment your model lives on a remote server or you need to pipe observations into a broader evaluation pipeline.

Community Performance Report Card

No community ratings yet. Be the first to rate this tool!

Best For: Researchers studying LLM internals, Developers debugging local model behavior, Users wanting to visualize J-space representations
  • Exposes J-space internal representations in real time before output tokens are committed, so you can observe the model's reasoning process rather than reverse-engineering it from outputs after the fact.
  • Session recording and browser-based replay via `record_session.py`, which means you can share a captured session with a colleague or step through a failure case hours after it happened without reconstructing the exact prompt conditions.
  • Fully self-hosted with no cloud dependency, so sensitive prompts and model states never leave the machine — critical for any research involving proprietary data or unpublished model weights.
  • Ships with a `verify_accuracy.py` script and a linked reference paper, so teams can audit whether the J-space instrumentation is behaving as the methodology describes rather than taking the visualization on faith.
  • No API and no integration hooks mean every observation stays inside the tool. Teams who want to log J-space states to a database, trigger alerts on specific internal patterns, or feed observations into an evaluation framework have to parse exported files themselves — that DIY layer adds maintenance burden fast.
  • Instrumentation is limited to local models the tool can attach to directly. The moment your model moves to a hosted endpoint — OpenAI, Anthropic, or any other remote API — Subtext goes dark. Teams running production models in the cloud will find nothing here to replace their existing black-box debugging approach, and at that point they switch to tools built around token-level logging or external evaluation harnesses instead.
  • Multi-turn session tooling exists (`test_multiturn.py`) but the project has 25 commits and no open issues or pull requests — community surface area is thin. Teams who hit an edge case with a specific model architecture have no forum, no community plugin layer, and no documented escalation path beyond reading the source.

About

Platforms
Python, local inference
API Available
No
Self-Hosted
Yes
Last Updated
2026-07-14T14:08:44.611Z

Best For

Who it's for

  • Researchers studying LLM internals
  • Developers debugging local model behavior
  • Users wanting to visualize J-space representations

What it does well

  • Observing model reasoning during live chat
  • Inspecting internal states before output tokens appear
  • Exporting and replaying model sessions for analysis
Help improve this page

Add notes, reviews, and benchmarks so the next visitor gets a clearer picture.

Sign in to contribute

Spotted incorrect or missing data? Join our community of contributors.

Sign Up to Contribute

Frequently Asked Questions

Is Subtext free?
Yes — Subtext is fully free to use. There is no paid tier.
Is Subtext open source?
Yes. Subtext is open source.
Can I self-host Subtext?
Yes. Subtext supports self-hosting on your own infrastructure.
What platforms does Subtext support?
Subtext is available on: Python, local inference.
Subtext

Most debugging tools for language models show you what came in and what came out. Subtext shows you what happened in between. The tool attaches to a locally-running language model and streams its J-space representations — internal states the model uses for multi-step reasoning — to a browser-based dashboard in real time. You can watch the verbal workspace shift as the model reads the prompt and before it commits to output tokens. Sessions can be recorded via `record_session.py`, exported, and replayed in the browser, so you can step through a conversation after the fact and inspect state at each turn.

The differentiating feature is the J-space instrumentation itself. Grounded in Anthropic research identifying a small set of internal representations that behave like a global workspace — contents that the model can verbally report, deliberately modulate, and causally use for reasoning — Subtext makes those representations observable rather than inferred. That is a different class of visibility than attention weights or token probabilities, and the repo includes a reference implementation and a paper link for teams who want to validate or extend the methodology.

Subtext fits tightly into one workflow: a researcher or developer with a local model who wants ground-truth visibility into reasoning steps, not just output quality. It breaks equally fast in two directions: any model running behind a remote API is outside its reach, and there are no hooks to feed observations into an external evaluation framework, a database, or a CI pipeline. Teams doing one-off debugging sessions will find it self-contained. Teams who need to track internal states across hundreds of runs and correlate them with downstream metrics will hit the export-and-do-it-yourself wall immediately.

The project ships with `server.py`, `test_client.py`, `test_multiturn.py`, and `verify_accuracy.py` alongside a `requirements.txt`, with Windows batch start support via `start.bat`. The interface is a single `index.html` served locally. There is no packaged binary and no install wizard — you clone, install dependencies, and run the server against a compatible local model.