Dexter: An Autonomous Financial Research Agent That Plans and Self-Validates

"Analyze a company's financial health over the past few years." Traditionally, that means you're the one doing the grunt work—pulling the financial statements, breaking down the numbers, cross-referencing everything by hand. Dexter wants to flip that on its head. You drop in the question, and the agent plans out the research steps, fetches real-time market data, checks its own work, and hands you back a conclusion with the data to support it.

The author, virattt, sums up the whole positioning in one line: think Claude Code, but built specifically for financial research. In other words, an autonomous agent that thinks, plans, and corrects itself as it goes.

So let's talk about how it actually works, because this is the interesting part. Dexter isn't just a RAG pipeline, and it isn't just "an LLM with a search tool bolted on." Its heart is a loop with three beats: plan, execute, self-validate. First it takes a messy, complex question and breaks it into structured research steps. Then it picks the right tools to go fetch data—things like income statements, balance sheets, cash flow statements from a financial data API, or a web search when it needs context. And then comes the part most agents skip: it looks at its own output and asks, "Is this actually complete?" If the answer is no, it loops back and keeps going. If yes, it writes up the conclusion. And every step along the way gets logged to an audit trail.

The official docs frame this as five core capabilities: intelligent task planning, autonomous execution, self-validation, real-time financial data access, and safety features. But I want to zoom in on a few design decisions that I think are genuinely worth paying attention to, because they tell you this thing was built by someone who's watched agents fail in the wild.

First one: loop detection and a step cap. Here's the classic way an autonomous agent dies. It keeps feeling like "I need just a little more data," so it calls another tool, and another, and another—iterating forever while your API bill and your clock both spiral. Dexter bakes in loop detection and a hard maximum on execution steps as first-class safety mechanisms, not as a patch someone slapped on after things went wrong. That's the basic line of defense that lets an agent actually survive in a real environment.

Second: the JSONL scratchpad. Every single query Dexter runs, it writes out a fresh log file—newline-delimited JSON, one event per line. And each line captures a specific kind of moment. There's the init event, which is your original question. There's tool_result, which records every tool call: the arguments it passed, the raw result it got back, and the LLM's summary of that result. And there's thinking, which captures the agent's reasoning steps. The payoff here is huge. Because every step leaves a trace, you can go back afterward and reconstruct exactly what data the agent fetched and how it interpreted it. When you're staring at a conclusion asking "wait, why did it decide that?"—this is how you find out.

Third: it ships with a real evaluation suite. Dexter tests itself against a dataset of financial questions, traces the whole thing with LangSmith, and scores correctness using an LLM-as-judge approach—basically, one model grading another's answers. You can run it across every question or just sample, say, ten of them. And while it runs, there's a live UI showing progress, the current question, and your running accuracy. The point of all this is that it turns a fuzzy question—"did quality actually go up after I switched providers or tweaked the prompt?"—into a number you can look at, instead of a gut feeling.

Fourth: it's multi-provider, switchable at the config layer. It defaults to OpenAI, but you can swap in Anthropic, Google, xAI, route through OpenRouter, or even run it locally with Ollama. And switching is just an environment variable—you never touch the agent logic. That's really convenient if you want to control cost or compare how different models handle the same research.

And fifth, a fun one: there's a WhatsApp gateway. You scan a QR code to connect your phone, then you message yourself in your own "chat with yourself," and Dexter picks it up, processes it, and replies right there in that same chat. If you live on your phone and don't want to open a terminal, that drops the barrier way down.

Quick word on the stack. Dexter runs on the Bun runtime—you'll want version 1.0 or higher. Once it's installed, you type "bun start" to jump into interactive mode, or "bun dev" for watch mode while developing. Financial data comes from the Financial Datasets API, which bills itself as institutional-grade market data for agents. For web search, Exa is the first choice with Tavily as a fallback, and both of those are optional. The whole thing is MIT licensed.

Now—and this matters—there's a disclaimer sitting right at the top of the README, and it's not boilerplate you should ignore. This is for educational, entertainment, and informational purposes only. Not for actual trading or investment. It is not financial, investment, tax, or legal advice. It makes no guarantee that its output is accurate, complete, or fit for any purpose. The output can be wrong, incomplete, or outdated. And there are two separate places that can go wrong: the financial data depends on the upstream API being correct, and the LLM's own reasoning can slip up. So realistically, this is a tool for exploratory research, for understanding how financial statements are structured, or for learning how to design autonomous agents—not something you take straight into a trading decision.

So let me leave you with three things to hold onto. First, the real architecture here isn't the data fetching—it's the plan, execute, self-validate loop, where the agent checks its own completeness and iterates instead of just answering once. Second, the safety and observability features are what make it real: loop detection and a step cap keep it from running away, and that per-query JSONL audit trail means you can always reconstruct why it concluded what it concluded. And third, keep the guardrail in mind—this is a fantastic way to learn agent design and explore financial data, but the disclaimer is doing honest work. The data can be wrong and the reasoning can be wrong, so treat its conclusions as a starting point, never as a verdict.