"Can You See What's Inside?" Examining LLM Steerling-8B and Running It on DGX Spark

Introduction

Hello, I'm Morishige from Classmethod's Manufacturing Business Technology Department.

Can you explain why an LLM gave the answer it did?

That's how I'm starting things off, podcast-style :)

When you ask ChatGPT or Claude a question, you get a plausible-sounding answer. But if you ask "why did you give that answer?", you only get a post-hoc explanation that sounds reasonable — you never learn the real reason. The current reality is that we have no choice but to keep using these systems as black boxes.

In February 2026, a startup called Guide Labs released Steerling-8B, an LLM with "interpretability built in from the design stage." They claim that every token in the output can be traced back to training data and concepts.

https://www.guidelabs.ai/post/scaling-interpretable-models-8b/

It sounded interesting, so I looked into it and actually ran it on my local DGX Spark.

What is Steerling-8B?

Guide Labs is a San Francisco startup that came out of Y Combinator Winter 2024. They raised a $9M seed round led by Initialized Capital.

CEO Julius Adebayo is a researcher who earned his PhD from MIT and is a co-author of the 2018 NeurIPS paper "Sanity Checks for Saliency Maps." This paper demonstrated that "post-hoc interpretation methods are fundamentally unreliable," which directly connects to Steerling's concept. The thinking goes: "If dissecting after the fact doesn't work, why not build transparency in from the start?"

Here is a summary of Steerling-8B's specs:

The parameter count is on the same scale as Llama 3 8B, but the architecture differs significantly from a typical LLM.

Why is "natively interpretable" something new?

Research into understanding what happens inside LLMs has been ongoing for some time. Anthropic's Sparse Autoencoder (SAE) is a well-known example, and "Golden Gate Claude" generated buzz in 2024 as well. However, these are approaches that dissect an already-trained model after the fact.

Steerling reverses this thinking by building interpretability in at the design stage.

Rather than the Transformer's Hidden States feeding directly into the output, they pass through a bottleneck layer called iGuide. Here, they are decomposed into 33,732 Known Concepts (with human-readable labels) such as "law," "medicine," "humor," and "politeness," along with 101,196 Unknown Concepts.

Because the path from concepts to output consists only of addition and multiplication, it is possible to precisely calculate "how much this concept contributed to the output." Rather than estimating after the fact, the structure itself guarantees transparency — that is Steerling's claim.

Two key technical features

Diffusion-based text generation

While a standard LLM generates tokens one at a time from left to right in an autoregressive manner, Steerling uses a method called Causal Diffusion.

The idea is that within a block of 64 tokens, positions with higher confidence are filled in first. It's a bit like writing where you decide on the key words first and then fill in the gaps. It is based on the MDLM paper from NeurIPS 2024.

iGuide (concept bottleneck)

The iGuide layer described above is the other key feature. It is an evolution of CB-LLM (Concept Bottleneck LLM) from ICLR 2025, and converts the Transformer's internal representations into "weights per concept" before generating the output.

What I personally found interesting is that the "weights" of the concepts can be manipulated at inference time. I'll try this out in the next section.

Running it on DGX Spark

Here's the main event. I ran Steerling-8B on my local DGX Spark (NVIDIA GB10 GPU, 128GB unified memory).

Environment setup

The DGX Spark has an ARM64 (Grace CPU) + Blackwell GPU (sm_121) configuration, and there were several gotchas during environment setup.

The steerling package requires Python 3.13 or higher. There were also issues with the availability of ARM64 wheels for the dependent PyTorch and Triton packages, causing uv add steerling to fail out of the box.

Specifically, I ran into the following two problems:

I also considered using an NGC container, but even the latest NGC version only supports up to Python 3.12, which doesn't meet steerling's Python 3.13 requirement, so I abandoned that approach.

I was ultimately able to resolve everything using uv's override feature. Here is the pyproject.toml:

[project]
name = "steerling-test"
version = "0.1.0"
requires-python = ">=3.13"
dependencies = ["steerling>=0.1.2"]

[tool.uv]
override-dependencies = ["triton>=3.5.0", "torch>=2.9.0"]

[[tool.uv.index]]
name = "pytorch-cu128"
url = "https://download.pytorch.org/whl/cu128"
explicit = true

[tool.uv.sources]
torch = { index = "pytorch-cu128" }

Running uv sync installs torch 2.10.0+cu128 and triton 3.6.0.

uv sync

PyTorch emits a warning that sm_121 is outside its officially supported range (8.0–12.0), but inference itself worked.

Here is the environment that actually worked:

Text generation

The following code is enough to load the model and run basic generation:

from steerling import SteerlingGenerator, GenerationConfig

generator = SteerlingGenerator.from_pretrained(
    "guidelabs/steerling-8b", device="cuda"
)

text = generator.generate(
    "The key to understanding neural networks is",
    GenerationConfig(max_new_tokens=100, seed=42),
)
print(text)

The first run downloads the model (approximately 17GB). Generation after loading worked without issues. Since this is a base model rather than an instruction-tuned one, it operates as text completion.

Playing with steering (concept control)

Let me try steering, Steerling's headline feature. You can pass a dictionary of concept IDs and weights to the steer_known parameter of GenerationConfig to increase or decrease the influence of those concepts during generation.

However, at this point there is no official API for looking up a concept ID by name. The official blog says it is "coming in the next few weeks" (as of March 2026).

So I worked around this by back-projecting from the model's internal weights to find which words each concept is close to, enabling keyword-based concept search.

# Project concept embeddings into the vocab via the LM Head
concept_emb = model.known_head.concept_embedding.weight  # (33744, 4096)
lm_head_weight = model.transformer.lm_head.weight  # (100281, 4096)

# Get the top tokens for each concept
logits = concept_emb @ lm_head_weight.T
topk_vals, topk_ids = logits.topk(10, dim=-1)

Here are some of the concepts I found using this method:

Now let's try changing the weight of concept 12348 (Tenant-landlord Legal Relations) with the prompt "When renting an apartment, the most important thing to consider is."

prompt = "When renting an apartment, the most important thing to consider is"

# Baseline (no steering)
config = GenerationConfig(max_new_tokens=100, seed=42, repetition_penalty=1.2)
text = generator.generate(prompt, config)

# Steering: boost the legal-related concept
config_steer = GenerationConfig(
    max_new_tokens=100, seed=42, repetition_penalty=1.2,
    steer_known={12348: 2.0}
)
text_steer = generator.generate(prompt, config_steer)

Here are the results:

Baseline output (no steering):

its location. Wherever you live in the world, your home should be
somewhere that suits your lifestyle and has easy access to all of
life's amenities.

What are some things to look for when buying a house?
1. Is it near public transportation? If so, how far away?
2. Are there any schools nearby?

Steered output (concept 12348, weight=2.0):

making sure that tenants pay rent on time. Rent eviction between a
tenant and landlord can be a stressful situation for both landlords
and tenants.

Rent evictions occur due to various reasons such as non-payment of
rent or other landlord-tenant disputes. Tenant eviction, rental
eviction...

The baseline gives general advice about location, schools, and transportation, while the steered version shifts focus to the legal relationship between tenants and landlords, and the eviction process. It's quite interesting how much the direction of the output changes just by adjusting the concept weight, even with the same prompt and the same seed.

When I set the weight to -1.0 to suppress legal-related content, the output returned to discussing property types and location. It feels like turning a dial on a concept.

One word of caution: setting the weight to 3.0 or higher causes the output to collapse into repeated tokens. The practical range is around 1.0 to 1.5.

Checking attribution (concept attribution)

Another feature of Steerling is the ability to see which concepts are contributing to each token.

text = "Python is a popular programming language"
token_ids = tokenizer.encode(text, add_special_tokens=False)
x = torch.tensor([token_ids], dtype=torch.long, device="cuda")

with torch.no_grad():
    logits, outputs = model(x, use_teacher_forcing=False, minimal_output=False)

# known_weights: weights for each token across 33,732 concepts
known_weights = outputs.known_weights[0]  # (T, 33732)

Let's look at which concepts are associated with each token for the input "Python is a popular programming language."

The fact that the "popular, famous" concept ranks at the top for popular with a weight of 0.98 is an intuitively satisfying result. On the other hand, for Python, what ranks at the top is not a concept related to the programming language name, but rather something closer to "type information." It appears the model recognizes "Python is a programming language" from context, while internally capturing it through a more abstract concept related to type systems — a glimpse into how the model "thinks."

However, the 33,732 labeled concepts (known concepts) only explained around 10% of the model's full internal state. The majority is accounted for by the 101,196 unlabeled unknown concepts. Even though "the inside is visible," the scope that can be covered by human-readable labels is currently limited.

Performance

I measured inference speed on DGX Spark (GB10).

Honestly, it is not fast. It is considerably slower compared to an autoregressive model of the same size. The main reason is that Attention processing optimizations are not yet effective, and the fact that the DGX Spark's GPU (GB10) is outside PyTorch's official support range likely plays a role as well.

On the other hand, the overhead of the steering feature was nearly zero. Even manipulating three concepts simultaneously added only about +0.3 seconds.

GPU memory usage was 16.3 GB, leaving plenty of headroom from the 128 GB of unified memory.

Scenarios where steering could be useful

Where might this steering feature be practically useful?

In the financial sector, there are obligations to explain loan decisions. Being able to trace the reasoning behind a decision back to specific concepts (including sensitive attributes) seems valuable from a regulatory compliance perspective. In clinical decision support for healthcare, being able to verify reasoning chains would also be useful.

The EU AI Act is scheduled to take full effect in August 2026, imposing explanation requirements on high-risk AI. Regarding the XAI (Explainable AI) market, estimates vary widely across research firms — Grand View Research projects a $21B market by 2030, while MarketsandMarkets estimates $210.6B^[1]. Regardless of the specific figures, it is universally recognized as a growth area, and the timing suggests there is real demand.

Current limitations

Here are some concerns I noted.

The context length is 4,096 tokens. That is modest compared to the 128K+ of frontier models. Only a base model is provided, with no instruction-tuned version yet. Inference speed is also slow, as mentioned above.

Compatibility with inference stacks is another challenge. Since vLLM and llama.cpp cannot be used as-is, you must use Steerling's own inference pipeline.

An official concept search API and steering tutorials have not yet been provided, with an announcement of "coming in the next few weeks." As of March 2026, there are also no independent third-party benchmarks to be found.

As for Japanese, the training data is primarily English, so it was not practical. Japanese tokens do appear in the output, but the content does not make sense.

Summary

I researched Steerling-8B and ran it on DGX Spark.

It is not something that will replace production LLMs right now. Given the context length, inference speed, and ecosystem maturity, there is still a gap before it reaches practical readiness.

That said, the experience of "turning a concept dial at inference time to steer the output" felt fresh. Unlike traditional methods for adjusting overall behavior through human feedback (such as RLHF), being able to suppress or boost only a specific concept in a targeted way felt like a genuinely new approach.

MIT Technology Review selected "mechanistic interpretability" as one of its 10 Breakthrough Technologies of 2026. As the competitive axis in AI shifts from "capability" to "reliability and transparency," I'll be keeping a close eye on how design-time-integrated approaches like Steerling evolve.

Reference Links

• Steerling-8B (HuggingFace)
• Guide Labs Official Blog
• GitHub Repository
• TechCrunch Article
• MDLM Paper (NeurIPS 2024)
• Anthropic Scaling Monosemanticity
• MIT Technology Review 2026 Breakthroughs