DEV Community: Wei Rongjie

LLM Agents Keep Failing in Production. Here's Why a Causal Architecture Might Be the Answer.

Wei Rongjie — Sun, 13 Sep 2026 06:56:49 +0000

An update on the DCS research program and what it means for agent builders.

If you've built and shipped LLM agents, you know the pattern. The model produces a clean trace. Every tool call looks right individually. The plan sounds plausible. And then — nothing works. The agent loops. It returns a confident wrong answer. It rewrites the entire context when a single tool fails.

After you've debugged a few of these, you start to suspect it's not a prompt engineering problem. It's deeper.

The diagnosis from DCS

DCS (Dynamic Causal Structure) is a cross-disciplinary research program that just went public with a ~200,000-word theoretical manuscript (DOIs: 10.5281/zenodo.22709952 and 10.6084/M9.FIGSHARE.33519052). It covers everything from cosmology to AI agents, but for developers, the relevant part is narrow and practical.

The core claim: next-token prediction optimizes for conditional likelihood, not for causal structure. It tells you what comes next given what you've already seen. It doesn't tell you which of its own assumptions would break if reality pushed back.

Here's the gap in tabular form:

What current LLMs do well	What they struggle with
Predict next token given context	Localize which assumption broke under perturbation
Generate plausible plans	Identify which parts of the plan are load-bearing
Synthesize from training data	Know when a tool result invalidates a prior step
Handle distribution that looks like training data	Re-derive downstream state after a single node changes

What DCS proposes as the fix

The DCS framework traces a chain that runs:

causal structure → causal persistence → causal compression
→ causal emergence → causal prediction → causal intervention

For agent engineering, the operational translation is straightforward:

Store dependency graphs, not just traces. Each tool call should annotate which prior assumption it depends on. When a tool returns unexpected data, the agent should know which upstream node to revisit.
Treat perturbation as first-class input. Errors, missing files, and user contradictions are not edge cases. They're the unit of work. A causal architecture localizes the affected node and re-derives only downstream state — it doesn't rewrite the whole context.
Explanation should be a subgraph, not a paragraph. When an agent explains itself, the output should be a view of its own dependency structure, not freshly synthesized text that may itself be hallucinated.
Separate prediction from intervention. Next-token prediction is necessary but not sufficient. The jump from "simulating multiple futures" to "deciding which causes to manufacture today" is the hard part — and it's where current agents consistently fail.

The AI risk angle

There's a corollary that should matter to anyone building AI systems with real-world access. DCS argues that the biggest risk from AI is not rebellion — it's loyal execution of wrong objectives at increasing speed and scale.

This isn't just an alignment philosophy. It has an architectural root. If an agent can't inspect its own causal assumptions — if it can't tell you which parts of its plan are speculative and which are load-bearing — then no amount of RLHF or human review will catch every error before it becomes an email that gets sent, a transaction that executes, or a robot action that lands.

The real variable isn't how smart the model is. It's how large its causal domain becomes — how much real-world intervention capability it can access through tools, APIs, and physical interfaces.

The "living theory" approach

One unusual feature: DCS is designed as an AI-native living theory. Multiple AI agents run in parallel as literature assistants, logic reviewers, fact-checkers, and adversarial debaters. New evidence enters, counterexamples are surfaced, weak propositions are downgraded, wrong ones exit. The theory version keeps updating.

This is relevant to developers because it's essentially the same architecture problem: how do you build a system that updates itself locally under perturbation instead of regenerating from scratch?

Launch details

The full program launches publicly on September 16, 2026 as a global online livestream:

English session: 09:00–11:30 Beijing time (Tuesday evening, September 15, US time zones)
Chinese session: 19:30–22:00 Beijing time
~2.5 hours, 130+ slide deck, live Q&A
Non-commercial — no product, no fundraising

More at https://MINDAS.ME.

Open questions for the DEV community

Where in your own agent stacks have you seen a failure that looks causal — a specific dependency broke — rather than just a statistical miss?
Is tool-use fine-tuning a permanent solution, or does it eventually hit the same causal-representation wall?
What's the cleanest experiment that would show whether an agent benefits from explicit dependency graphs?

Drop your thoughts in the comments. The author will be reading.

DCS is an independent research program. It does not claim peer review or institutional endorsement. Claims in this article are presented as proposals within the DCS framework, not established scientific consensus.

Do AI Agents Need a Causal Architecture, or Is Next-Token Prediction Enough?

Wei Rongjie — Sat, 12 Sep 2026 10:29:00 +0000

A few weeks ago I watched a well-funded agent demo crash. The model had a clean tool-calling loop and a beautiful UI. It was asked: "Why did you retry that tool call?" It answered confidently. Then it answered a different question. Then it contradicted itself.

That failure wasn't about context length. It was about causal transparency: the agent couldn't explain the causal chain of its own decisions.

The next-token contract is a correlation engine

Transformers are trained on one objective: predict the next token. This is enormously powerful, but it optimizes for statistical consistency, not causal validity. A model can hold the right answer in its attention heads without holding a model of why that answer causes the next step.

We see the symptom in production every week:

Hallucinated tool calls that "look right" but violate API contracts
Agents that loop on the same retry because they can't distinguish "I failed" from "the tool failed"
Plausible explanations that don't match the trace
Planning that degrades under small perturbations of the prompt

The debate in 2025–2026 is whether scale alone closes this gap. My read: it doesn't, because the gap isn't a compute problem. It's an architecture-of-representation problem.

What a causal architecture would actually look like

This is where I want to open a discussion rather than preach. Here is the working hypothesis I've been building (dubbed DCS — Dynamic Causal Structure):

State, not just tokens. An agent should maintain an explicit causal graph of its own situation: what node caused what, which edge is uncertain, which assumption is load-bearing.
Disturbance response. Real agency is tested by perturbations — a tool returns an error, a file is missing, a user contradicts you. A causal graph updates locally; a next-token model reflows globally and often silently rewrites its own prior.
Explanation as a first-class artifact. When you ask "why," the answer should be a subgraph, not a plausible sentence.
Scale across domains. The same causal bookkeeping that explains a tool-call failure should explain a cell's metabolism, a neuron's firing pattern, and a civilization's transition. That's an ambitious bet, but I think the alternative — separate theories for physics, biology, and intelligence — has already failed to produce a unified research program.

The uncomfortable counterargument

I want to steelman the "scale is enough" position, because it's worth taking seriously:

Modern models already learn implicit causal structure from training data. Physics, grammar, and tool usage all have causal structure embedded.
Fine-tuning on trajectories seems to fix most agent failures in practice.
Causal-symbolic approaches (GOFAI, expert systems) have repeatedly promised transparency and delivered brittleness.

The reply, I think, is that implicit structure is fine when the distribution is narrow, and fails exactly when agents leave the textbook. Production agents operate under distribution shift by definition — that's the whole point of autonomy.

What I'm actually building

I'm not here to sell a framework. I'm publishing a ~200,000-word research program called DCS (Dynamic Causal Structure) that tries to do three specific things:

Define a single causal-structure primitive that applies from the Big Bang through chemistry, biology, neural systems, and finally AI agents.
Derive testable predictions about where token-prediction systems should and shouldn't break.
Treat the theory itself as a living agent — a document that updates as evidence comes in.

The launch is a live online session on September 16, 2026 (English session 09:00–11:30 Beijing; Chinese session 19:30–22:00 Beijing). It's ~2.5 hours, mostly animation, with a 138-slide deck. More here: https://MINDAS.ME

Questions I'd love to hear from you

Have you hit a production agent failure that looks causal rather than statistical?
Do you think tool-use fine-tuning is a local patch or a permanent solution?
What's the cleanest falsification test for a "causal architecture" claim?
Is cross-disciplinary unification (physics → life → mind → AI) actually productive, or is it a philosopher's trap?

Drop a comment. I'd rather be wrong in public than right in a slide deck.