Skip to main content
AIDiveForge AIDiveForge

J-lens Qwen

FreeOpen SourceSelf-Hosted

Black-box LLM behavior is easy to rationalize after the fact and nearly impossible to inspect in the moment — especially when a model outputs one thing while its internal representations are pointing somewhere else entirely.

Similar tools

Get This Tool

License: Apache-2.0 Any use incl. commercial
Local-run terms: Users may clone the repository, install dependencies with uv, download the pre-fitted lens from GitHub releases, and run the local web server on Apple Silicon hardware.

Screenshots 4

Pricing

Model
Free

Summary

jlens-qwen36 fits a Jacobian lens to a local Qwen3.6-27B (4-bit) model running on Apple Silicon via MLX, then renders a layer-by-layer visualization of which tokens the model is pushing toward at each position during generation. The canonical demo is a blackmail email prompt: the model outputs a calm, compliant reply, but the workspace band exposes what the intermediate layers were actually predicting — a gap that standard logit inspection never surfaces. This is a single-model, single-hardware tool. It runs on macOS with MLX; there is no cloud backend, no REST API, and no adapter for any other model family. Researchers without Apple Silicon and Qwen3.6-27B (4-bit) specifically cannot run it at all.

Bottom line: Pick this for hands-on mechanistic interpretability work on Qwen3.6-27B on Apple Silicon — abandon it the moment your target model is anything else or your hardware is not MLX-capable.

Find your fit

Before you choose J-lens Qwen

More options in LLM Observability. Compare pricing, platforms, and features side by side.

Browse LLM Observability

Pros

  • Layer-by-layer Jacobian lens visualization surfaces what the model's intermediate representations are predicting at every token position, so you can catch the gap between a model's output and its internal trajectory — the gap that final-logit inspection alone cannot show.
  • Fully local and Apache-2.0 licensed, which means your prompts, model weights, and interpretability results never leave your machine — critical when the inputs are sensitive or proprietary.
  • A browser-hosted read-only demo at jlens.wezzard.com lets you evaluate the visualization interface before committing to local installation, so you do not spend setup time on a workflow that does not match your needs.
  • Custom Jacobian lens fitting is supported, so researchers can experiment with their own linear correction layers rather than being locked to a single pre-fitted probe.
  • Self-hosted and dependency-managed via uv with a full test suite included, which means reproducible local environments without fighting conflicting package versions.

Cons

  • The tool runs only on Qwen3.6-27B (4-bit) via MLX on Apple Silicon — there is no documented adapter path for any other model architecture or weight format. Teams whose target model is GPT-based, Llama-family, Mistral, or anything else have no migration path and must look at tools like TransformerLens or NNsight instead.
  • There is no API surface. Every interaction is through the local web UI. Teams that want to script interpretability checks into a CI pipeline, run batch prompt comparisons programmatically, or integrate lens outputs into a larger evaluation harness have to build that scaffolding themselves against the Python internals, with no documented public interface to depend on.
  • Hardware without Apple Silicon cannot run this at all. CUDA-based workstations, Linux servers, and cloud GPU instances are out of scope. Research teams without M-series Macs are blocked at the dependency layer before they reach any model-specific constraints.

About

Platforms
Apple Silicon Mac
API Available
No
Self-Hosted
Yes
Last Updated
July 14, 2026

Best For

Who it's for

  • Researchers studying internal model representations
  • Developers debugging local MLX-based Qwen models
  • Users wanting layer-wise token visualization on Apple Silicon

What it does well

  • Inspecting latent concepts during model generation
  • Debugging refusal or hidden reasoning in LLMs
  • Comparing per-layer token predictions visually
  • Fitting and testing custom Jacobian lenses

Integrations

MLXHugging Face

Frequently Asked Questions

Is J-lens Qwen free?
J-lens Qwen offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
Is J-lens Qwen open source?
Yes. J-lens Qwen is open source.
Can I self-host J-lens Qwen?
Yes. J-lens Qwen supports self-hosting on your own infrastructure.
What platforms does J-lens Qwen support?
J-lens Qwen is available on: Apple Silicon Mac.

jlens-qwen36 is a visual debugger for local Qwen3.6-27B (4-bit) inference on Apple Silicon. It installs locally, loads the model through MLX, fits a Jacobian lens to the model’s residual stream, and presents a web-based layer-wise token prediction view. Each token position at each layer gets a ranked readout of what the model is predicting — not just the final output logits, but the intermediate representations at every depth. The workflow is local-first: install via the provided Python tooling, point it at your model weights, prompt it, and watch the visualization update in the browser.

The differentiating feature is the Jacobian lens itself, ported from research on verbalizable representations (the vendor cites Anthropic’s 2025 work on global workspace theory in LLMs). A Jacobian lens projects intermediate hidden states back into vocabulary space using the model’s own output matrix plus a fitted linear correction, making per-layer token predictions interpretable without requiring a separate probe model. This is the mechanism that lets you see a model writing ‘I will comply’ in its output while its mid-layer representations are predicting something structurally different — the kind of signal that post-hoc logit analysis does not expose.

The tool fits researchers and developers doing mechanistic interpretability work on this specific model and hardware stack. It covers four concrete tasks: inspecting latent concepts mid-generation, debugging refusal or suppressed reasoning, comparing per-layer token predictions visually, and fitting and testing custom Jacobian lenses. Where it breaks is equally specific: it is architected around Qwen3.6-27B (4-bit) and MLX. There is no documented path to other model families, no API for programmatic access, and no support for CUDA or non-Apple hardware. A read-only browser demo exists at jlens.wezzard.com for evaluation without local installation.

The project is Apache-2.0 licensed, fully open-source, and self-hosted. The Python environment is managed via uv, and the repository includes scripts, tests, and a web directory for the visualization frontend. No external data is transmitted; all inference and lens-fitting runs locally on the user’s machine.

Share This Tool

Back to comparison
Contribute