Causal Agent based on Large Language Model

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Next we'll be talking about the paper "Causal Agent based on Large Language Model".

Jane: The paper was written by Kairong Han, Kun Kuang, Ziyu Zhao, Junjian Ye and Fei Wu from Zhejiang University and Huawei Technologies Company.

Tom: Stay tuned as we take you through the paper and discuss its implications.

Jane: We also have Lu with us today — senior AI researcher at Tsinghua.

Tom: We also have Meng with us today — lead engineer at a mysterious AI startup.

Jane: We also have Lalam with us today — the in-house Large Language Model.

Tom: Alright, let's get started.

Title: Tom: Welcome back to the show, everyone. Today we’re looking at a paper that’s been making waves on arXiv, and it’s called “Causal Agent based on Large Language Model.” Jane, I have to say, the title alone got me curious — we’re talking about giving LLMs the ability to actually reason about cause and effect, not just pattern-match.

Jane: Absolutely, Tom. And the authors — Kairong Han, Kun Kuang, Ziyu Zhao, Junjian Ye, and Fei Wu — they’re from Zhejiang University and Huawei. That’s a solid mix of academia and industry. The core idea is that LLMs are great at language, but when you hand them a spreadsheet of data and ask “does smoking cause lung cancer?” they kind of freeze.

Tom: Right, and that’s the gap they’re trying to close. The paper argues that causal reasoning is inherently hard for LLMs because causal problems are usually about tabular data, not natural language. And the theory itself is hard to describe in words. So they built an agent that uses tools to bridge that gap.

Jane: And that’s where the “agent” part comes in. Instead of asking the LLM to reason directly, they give it access to causal analysis libraries — like causal-learn and EconML — and let it call those tools to analyze the data. The LLM becomes the brain that decides which tool to use and how to interpret the results.

Tom: So it’s like giving a chef a kitchen full of appliances instead of asking them to cook with their bare hands. The LLM still does the thinking, but it has the right equipment to actually get the job done.

Jane: Exactly. And the implications are huge. If this works, we could automate a lot of scientific discovery — not just in medicine, but in economics, social science, anywhere you need to figure out what actually causes what. That’s a big deal.

Tom: And the authors are careful to model the problem at four levels — variable, edge, graph, and effect — so it’s not just one trick. They’re building a whole framework for causal reasoning. I’m excited to see how they tested it.

Jane: Me too. Let’s get into the details of how they actually structured the problem and what the results look like. That’s coming up next.

Summary: Tom: So we’re back with “Causal Agent based on Large Language Model,” and Jane, we were just talking about the four levels of causal problems they defined. Can you break those down for our listeners?

Jane: Sure, Tom. The first level is the variable level — that’s basically asking whether two variables are correlated or independent. The second is the edge level, where you ask about direct causal relationships, like whether A directly causes B. Then there’s the causal graph level, where the agent has to generate a whole network of cause-and-effect relationships. And finally, the causal effect level, where you’re quantifying things like the average treatment effect — how much does changing one variable change another.

Tom: And they built a benchmark called CausalTQA to test all of this. About one thousand four hundred questions across those four levels. What did they find?

Jane: The results are pretty impressive. At the variable level, they’re hitting over ninety-five percent accuracy on all three sub-problems. At the edge level, it’s over eighty-nine percent. The causal graph level is a bit lower — around eighty-one percent for full graphs and ninety-one percent for partial graphs — but still strong. And the causal effect level is at ninety-eight percent.

Tom: That’s really strong. But here’s what I find interesting — they compared against a baseline called code-LLM, where the model just writes Python code to analyze the data. And that baseline performs terribly, sometimes even worse than random.

Jane: Right, and that’s the key insight. It’s not that LLMs can’t reason about causality at all — it’s that they need the right scaffolding. When you give them tools and a structured way to use them, they can do really well. The code-LLM baseline struggles because it has to figure out everything from scratch, and it makes all sorts of errors — wrong variable names, syntax errors, logic mistakes.

Tom: So the agent framework is doing the heavy lifting. The LLM is still the decision-maker, but it’s working with reliable tools instead of trying to reinvent the wheel every time.

Jane: Exactly. And they also tested on a real-world dataset called QRData, and their agent beat the previous state-of-the-art by six percent. That’s a big deal because it shows the approach generalizes beyond synthetic data.

Tom: And that’s the part that gets me excited — this isn’t just a lab experiment. It’s actually working on real problems. But I’m curious about how the agent actually decides which tools to use and in what order. That’s the planning part, right?

Jane: Yeah, that’s the ReAct framework — the agent thinks, acts, observes, and repeats. It’s like a scientist running experiments: you try something, see what happens, and adjust. We should talk about how that planning process works in more detail.

Improvements: Tom: We’re back with “Causal Agent based on Large Language Model,” and Jane, we’ve covered the results, but I want to dig into the actual improvements this paper proposes. What makes this agent different from just giving an LLM a Python interpreter?

Jane: Great question, Tom. The biggest improvement is the memory module. Instead of storing everything as text, the agent keeps a dictionary where the keys are names and the values are actual causal graph objects. So when the agent generates a causal graph, it can save it and reference it later without having to regenerate it.

Tom: That’s clever. So it’s like having a whiteboard where you can write down intermediate results instead of trying to remember everything in your head.

Jane: Exactly. And that’s crucial because solving a complex causal problem might require multiple steps — first generate the graph, then check if there’s a confounder, then maybe estimate a causal effect. If you lose the graph between steps, you have to start over.

Tom: And that’s where the planning module comes in. The agent uses a ReAct-style loop — it thinks about what to do, takes an action, observes the result, and decides whether it can answer the question or needs to keep going. On average, it takes about two point five iterations per question.

Jane: And the tools themselves are re-encapsulated so they accept JSON input and produce natural language output. That’s a subtle but important improvement — the LLM doesn’t have to parse complex data structures. It just gets a clear, readable result.

Tom: So it’s like the difference between giving someone a manual in a foreign language versus translating it into their native tongue. The tools speak the LLM’s language.

Jane: Right. And they also use in-context learning with one-shot examples to show the agent how to use the tools. That helps it understand the format and the intent of each tool before it starts.

Tom: I also noticed they tested with different LLMs as the decision core — GPT-three point five, ChatGLM-four-air, and ChatGLM-four-plus. The stronger the model, the better the results. So the framework scales with the underlying model’s capabilities.

Jane: That’s a good sign. It means the framework isn’t tied to one specific model — it’s a general approach that can improve as LLMs get better. And that’s the kind of forward-looking design you want to see.

Tom: And they even compared against RestGPT, another agent framework, and their causal agent did much better. That suggests the specialized design matters — you can’t just slap any agent framework on top of causal tools and expect it to work.

Jane: Exactly. The causal graph as an intermediary — that’s the secret sauce. It ties everything together and lets the tools share information in a meaningful way.

Tom: So what does this mean for the future? I’m thinking about real-world applications — healthcare, economics, policy-making. Where do you see this going?

Jane: I think the potential is enormous. Imagine an AI assistant that can analyze clinical trial data and tell doctors which treatment actually works, or a tool that helps economists understand the real drivers of inflation. That’s the kind of impact this could have.

Conclusion: Tom: We’ve had a great conversation about “Causal Agent based on Large Language Model,” and I think we’ve only scratched the surface. Jane, what’s the big takeaway for our listeners?

Jane: The big takeaway is that LLMs don’t have to be bad at causal reasoning. They just need the right tools and the right framework. By giving them access to causal analysis libraries and structuring the reasoning process, we can turn them into powerful causal reasoners — and that’s a huge step forward.

Tom: And it’s not just about the results, which are impressive — over ninety-five percent accuracy on variable-level questions, ninety-eight percent on causal effect estimation. It’s about the approach. The agent is transparent, interpretable, and reliable. You can see every step it takes, which is crucial when you’re making decisions that affect people’s lives.

Jane: Absolutely. And the fact that it generalizes to real-world data — beating the previous state-of-the-art by six percent on QRData — shows that this isn’t just a synthetic benchmark trick. It works in practice.

Tom: I also love that the authors made their code available on GitHub. That’s going to accelerate research in this area. Other teams can build on this framework and push it even further.

Jane: And that’s the exciting part — this is just the beginning. As LLMs get better and causal tools get more sophisticated, we’re going to see agents that can tackle even more complex causal problems. Maybe even ones that can design their own experiments or discover new causal relationships we hadn’t thought of.

Tom: Well said, Jane. So let’s say goodbye to “Causal Agent based on Large Language Model” and get ready for the next paper. This one’s going to be a hard act to follow.

Jane: Agreed. Thanks for listening, everyone. We’ll be back soon with more exciting research from arXiv.

Tom: Until next time, keep asking why — and maybe someday, your AI assistant will be able to answer.