The default instinct with large language models is to make one model smarter. Bigger context, sharper prompt, a better system message. [TradingAgents](https://github.com/tauricresearch/tradingagents) bets on the opposite move: take a lot of narrow agents, give each one a single job, and force them to argue before anyone acts. It's open-source software that simulates an entire investment firm. Four analysts gather evidence, a bull and a bear fight over it, a trader writes a proposal, and a three-voice risk team plus a portfolio manager sign off. One function call walks a stock through all of them. The stock pick is the demo. The architecture is the product. Here's how it works under the hood. ## You type a ticker. A firm wakes up. Walk up to a real firm and ask, **"Should I buy NVIDIA stock, as of May 10th?"** No single person answers. The question gets routed: analysts research it, a room debates it, a risk team pokes holes, a manager signs off. TradingAgents recreates that chain in software. Every "person" is an LLM agent with exactly one role — the same way a real employee owns one lane. ### The entire program is basically three lines The file a user actually runs is tiny. You describe the firm, then you ask it one question. ```python from tradingagents.graph.trading_graph import TradingAgentsGraph from tradingagents.default_config import DEFAULT_CONFIG config = DEFAULT_CONFIG.copy() # Initialize with custom config ta = TradingAgentsGraph(debug=True, config=config) # Forward propagate _, decision = ta.propagate("NVDA", "2024-05-10") print(decision) ``` What each line does: - Pull in the firm builder and the default settings (which models to use, how many debate rounds, and so on). - Make a private copy of the settings so you can tweak them without touching the originals. - Build the firm. `debug=True` just narrates every step out loud so you can watch. - Ask the question: `"NVDA"` is the stock, `"2024-05-10"` is the date to pretend it is, and `propagate` pushes it through the whole firm. - Print the final verdict — Buy, Hold, Sell. ### Follow your question through the building `propagate("NVDA", ...)` doesn't answer instantly. Your request travels through stations, like a story moving through that newsroom: 🙋 You → 🔬 Analysts → 🐂 Researchers → 💼 Trader → ⚖️ Risk Team → ✅ Portfolio Mgr That left-to-right journey is the spine of the whole app. Every section from here zooms into one station. ### The answer isn't a number. It's a memo. The firm doesn't spit out "BUY." It writes a decision memo with a five-tier rating, from Sell up to Buy. A small piece of code then reads the rating back out of the prose so the rest of the program can use it. ```python def process_signal(self, full_signal: str) -> str: """Return one of Buy / Overweight / Hold / Underweight / Sell.""" return parse_rating(full_signal) ``` What it does: - Take the full written memo (a long paragraph of reasoning). - Hand it to a helper that scans for the rating line and pulls out the one-word verdict. - That single word is what `decision` holds when you `print` it. ## Meet the team A symphony has sections — strings, brass, percussion — and nobody asks the timpani player to also conduct. TradingAgents is built the same way: small groups of agents, each handing work to the next. There are **four sections**, in the order your question travels. Section 1 · The Analyst Team: gather evidence Market Analyst reads price charts and technical indicators (moving averages, RSI, MACD). The chartist of the firm: it cares about patterns in the numbers, not the company's story. Sentiment Analyst gauges the mood from news headlines, StockTwits, and Reddit chatter to read short-term crowd psychology around the stock. News Analyst tracks world events and macro (interest rates, trade wars) and judges how those forces hit this particular stock. Fundamentals Analyst digs into the company's financials (balance sheet, cash flow, income) to estimate what the business is really worth. Section 2 · The Researcher Team: argue both sides 🐂 Bull Researcher is the optimist. It reads all four analyst reports and builds the strongest possible case to BUY: growth, advantages, good news. 🐻 Bear Researcher is the skeptic. It builds the strongest case to AVOID — risks, weaknesses, threats — and rebuts the Bull directly. ⚖️ Research Manager is the judge. It listens to the bull-vs-bear debate and writes a balanced investment plan declaring who won and why. Section 3 · The Trader: propose the trade 💼 Trader turns the research manager's plan into a concrete proposal: direction and conviction. It's the bridge between "what we think" and "what we'd actually do." Section 4 · Risk Team + Portfolio Manager: stress-test and sign off 🔥 Aggressive Analyst pushes for bold exposure, arguing the upside is worth the danger. 🛡️ Conservative Analyst argues to protect capital: smaller size, more caution. ⚖️ Neutral Analyst is the tie-breaker, weighing the aggressive and conservative views for a balanced middle path. ✅ Portfolio Manager is the editor-in-chief. It reads the risk debate and writes the final, binding decision with a Buy-to-Sell rating. ### In the code, each agent is a node Here's where the firm gets staffed. Each line registers one agent as a node — one station on the assembly line. Read it like an org chart written in code. ```python workflow.add_node("Bull Researcher", bull_researcher_node) workflow.add_node("Bear Researcher", bear_researcher_node) workflow.add_node("Research Manager", research_manager_node) workflow.add_node("Trader", trader_node) workflow.add_node("Aggressive Analyst", aggressive_analyst) workflow.add_node("Neutral Analyst", neutral_analyst) workflow.add_node("Conservative Analyst", conservative_analyst) workflow.add_node("Portfolio Manager", portfolio_manager_node) ``` Each line hires one role and gives it a desk: the Bull and Bear so both sides of the debate exist, the Research Manager who judges it, the Trader who turns the verdict into a proposal, the three risk voices, and the Portfolio Manager who signs. The string is the name tag; the second argument is the actual worker. ### Why two sizes of "brain"? Not every agent needs the same horsepower. The firm wires up **two** models: a fast, cheap one for routine work, and a slower, more powerful one for the high-stakes judgment calls. ⚡ Quick-thinking model Used by analysts, researchers, the trader, and risk voices. Cheaper and faster per call, good enough for gathering evidence and arguing. 🧠 Deep-thinking model Used by the Research Manager and Portfolio Manager. Pricier, slower, more careful — reserved for the binding final judgments. ## The org chart is the product One line of code becomes a debated, risk-checked decision, and you now know where every piece lives. A single entry point hides a newsroom of narrow agents: analysts gather evidence, researchers argue both sides, a trader proposes, a risk team and portfolio manager sign off. None of that reliability comes from a smarter model. It comes from structure — narrow roles, adversarial debate, a cost-tiered split, and one clean door over the whole thing. That's the pattern worth stealing. Don't build one genius agent. Build an org chart, and make it argue with itself.