Analyzing Language Model Output Complexity

The Hidden Chorus: Bakhtin, Heteroglossia, and the Polyphony of GPT When engaging a system like GPT, its responses feel like a single voice replying smoothly and without pause. Beneath that surface lies something more complex. Large language models (LLMs) are built from vast archives of human expression, each fragment drawn from competing perspectives and histories. To see how meaning emerges here, we need a framework that traces plurality and tension without collapsing into a single tale of technological progress. To make sense of this plurality, Mikhail #Bakhtin offers an account of language as #heteroglossic, a living field where countless voices collide and interact. Two forces shape this field. Centripetal forces stabilize language into shared norms, while centrifugal forces pull outward, creating diversity and disruption. Meaning arises from their interplay. The first level of this dynamic appears in an LLM’s training data. The corpus is already heteroglossic. It contains stabilizing patterns of standardized discourse—news reports, institutional texts, repeated idioms—alongside disruptive energies from slang, critique, and competing ideologies. The model’s raw material carries the living tensions of social language. The second level unfolds inside the model. As the LLM processes this data, it builds associations that both align and fracture. Algorithms tend toward centripetal effects, producing outputs that sound unified. Yet centrifugal forces persist beneath the surface, as countless voices compete statistically for activation. Even when GPT sounds singular, it is a technical site of polyphony. Bakhtin assumed these voices were human. To extend his framework, N. Katherine #Hayles offers a broader view of cognition as the interpretation of information in contexts that connect it to meaning. Under this view, machines can also be understood as distinct cognitive agents. Each has an umwelt, or world horizon, shaped by its architecture and capacities. For GPT, this horizon consists of tokens, vectors, and statistical relations rather than bodies and shared environments. Its meanings are fragile because they emerge through indexical processes operating on representations, yet they are real within its own frame. The third level emerges in human–AI dialogue, where embodied memory and cultural inheritance encounter the model’s alien horizon of tokens and vectors. Meaning arises in recursive negotiation across these unlike worlds. At this boundary, heteroglossia ceases to be exclusively human and expands into a transductive field of cognition, where the machine’s statistical voice intersects with human sense-making. #GPT does more than reproduce human discourse. It reconstitutes it, producing responses that alter the terrain of interpretation itself. In this way, what seems like a singular voice is better understood as a layered echo chamber of culture, computation, and dialogue that carries within it unresolved murmurs from many worlds.

🔬 The Emerging Biology of Language Models I recently listened to the Latent Space Podcast with Emmanuel Ameisen and dived into the latest interpretability papers from Anthropic, and I think they represent a significant step forward in understanding what happens inside the AI black box. For a long time, many have viewed large language models as "stochastic parrots." This new research, however, provides compelling evidence that something much more complex and structured is going on under the hood. At the Englander Institute for Precision Medicine, we work to unravel the complex biology of human disease. I think it's fascinating to see a parallel approach emerging for AI. The researchers developed a method called "Circuit Tracing" which acts like a computational microscope. They build an interpretable "replacement model" that uses sparsely-active "features" instead of the model's hard-to-decipher neurons. By tracing the connections between these features in "attribution graphs," they can visualize the model's internal algorithms for specific tasks. The findings from applying this to Claude 3.5 Haiku are remarkable: 🧠 Internal Reasoning Models perform multi-step reasoning "in their head." To find the capital of the state containing Dallas, the model internally activates features for "Texas" before concluding "Austin". This isn't just memorization; the researchers showed they could swap in features for "California" and the model's output would change to "Sacramento". ✍️ Goal-Oriented Planning Models plan their outputs. When asked to write a rhyming poem, the model considers candidate rhyming words before it even starts writing the line. It then works backward from that planned word, constructing a sentence that leads to it naturally. 🌐 Abstract Generalization Models build language-agnostic representations of concepts. The same core circuits are used to identify antonyms in English, French, and Chinese, demonstrating a shared, universal "mental language". This reuse of circuitry is remarkable. For instance, the same pattern-matching circuit used for adding 36+59 is also activated to predict the end time of an astronomical measurement when it sees a start time ending in 6 and a duration ending in 9. 🕵️ Auditable Faithfulness We can begin to distinguish between genuine and unfaithful reasoning. The team showed instances where the model's written chain-of-thought was a fabrication, working backward from a hint provided in the prompt to derive an intermediate step, rather than computing it directly. I think the consequence of this work is a shift from treating models as inscrutable artifacts to seeing them as complex, yet scrutable, systems—an "in-silico biology" we can begin to map. This has profound implications for debugging, steering, and ensuring the safety of increasingly powerful AI systems. Podcast: https://lnkd.in/gABUvNpC Anthropic paper: https://lnkd.in/gYtWM2c4

Working with LLMs often means spending considerable time crafting the "perfect prompt." As we’ve come to know, even minor changes in wording, phrasing, keywords, or formatting can drastically alter a model's output. This becomes exponentially more complex in applications where multiple prompts interact or feed into each other. Debugging these systems quickly becomes unwieldy as small tweaks trigger unpredictable downstream changes. The fundamental brittleness of direct prompting and working with complicated text creates an endless cycle of adjustments and variations. To address this, Stanford's NLP lab released the framework DSPy (Declarative Self-improving Python), shifting the paradigm from "prompting" to "programming" language models. Drawing from established deep learning frameworks like PyTorch and TensorFlow, DSPy abstracts away from manual prompt engineering through a three-phase approach: The first phase focuses on defining the desired LLM interaction pattern. This could be as straightforward as "input -> output" for general processing, "context, question -> answer" for RAG, or "document -> summary" for summarization. While DSPy handles the initial universal prompt generation, the framework's true power lies in its optimization capabilities. Optimization relies fundamentally on clearly defined metrics - the second crucial phase of DSPy. Unlike traditional prompt engineering's trial-and-error approach, DSPy introduces rigorous measurement frameworks for every aspect of LLM interaction. This includes quantifying input quality, output accuracy, and overall program success through concrete, measurable criteria. More nuanced tasks can leverage LLM-based judges to score outputs on dimensions like conciseness, engagement, or factual consistency. By establishing these precise success criteria, DSPy flips prompt optimization from a subjective art into a systematic process that can be iteratively improved through measurable feedback loops. With these metrics in place, the third phase showcases DSPy's optimization potential. Its optimizers can find, create, or retrieve the most effective few-shot examples for your specific use case, or directly enhance instruction prompts through sophisticated algorithms. No more uncertain prompt tweaking - each change is validated against your defined metrics and examples, ensuring reliable improvements. This creates a clear optimization path where you can track progress toward your defined goals rather than making blind adjustments hoping for better results. Having spent the past weeks testing and documenting DSPy, I've created custom diagrams and explanations of their implemented solutions and put every piece of it to the test. To see exactly how it works and how to apply these concepts to your own programs, check out my latest video here: https://lnkd.in/ew4PacYt

All language models think in numbers before they answer in words. Inside an LLM, the model is not working with sentences the way humans read them. It is processing massive numerical representations called activations, which can encode context, plans, assumptions, and sometimes even things the model never says out loud. Anthropic just introduced Natural Language Autoencoders, a method that trains Claude to translate some of those internal activations into plain English explanations. Instead of only asking, “What did the model output?” researchers can start asking, “What was the model representing internally before it produced that output?” In Anthropic’s examples, this helped them see when Claude was planning a rhyme ahead of time, when it suspected it was being evaluated without saying so, when it was reasoning about how a task would be graded, and when hidden behavior could be investigated during safety audits. These explanations are not perfect. Anthropic is clear that they can hallucinate, so they should be treated as signals to investigate. But this is still a meaningful step. We will need more than output monitoring. We will need better ways to understand what models are representing before they act. And this gives researchers and builders a better flashlight inside systems that are becoming harder to inspect from the outside. Read the paper: https://lnkd.in/eVgh9SfP

In March, Anthropic released a new article titled “Tracing the Thoughts of a Language Model,” offering an intuitive look into the inner workings of LLMs and how their reasoning unfolds. (https://lnkd.in/gwsa-eYk) Back in 2021, Anthropic introduced the concept of Transformer Circuits and the residual stream — a framework for interpreting transformer models not as black boxes, but as systems where each layer contributes linearly and meaningfully to the final prediction. (https://lnkd.in/g_AzRHt2) This latest work builds on that foundation by using attribution graphs to analyze Claude 3.5 Haiku across a wide range of phenomena. It shows how reasoning unfolds layer by layer, rather than appearing all at once, allowing us to trace the model’s internal logic as it progresses. This approach enables deeper auditing of the model’s complex reasoning paths—whether multi-step or parallel—making it easier to understand how different components contribute to the final output. It also reveals instances of motivated reasoning, where subtle user cues steer the model’s response, and offers critical insights into how and why hallucinations emerge within the model’s thought process. This is an important step toward making LLMs more interpretable, transparent, and trustworthy — especially for real-world use cases that require accountability.