If you follow public companies for a living (or a hobby), you already know the grind: pull the latest transcript, skim the prepared remarks, hunt through Q&A for the one thing management is being cagey about, then repeat for a competitor and the last three quarters. It's mechanical, and mechanical work is exactly what agents are good at.

An earnings research agent is an AI agent that does this loop for you. Instead of you clicking through pages, the agent decides which calls to pull, reads the transcripts, compares quarters, and hands back a written brief. You give it a ticker and an intent ("what changed on margins this quarter?") and it plans the steps, calls the tools, and synthesizes an answer.

This post walks through how to build one on top of the EarningsCalls MCP server and Claude. It's aimed at developers and indie builders who are comfortable with a terminal and want something running today, not a research paper.

Why MCP is the right substrate

You could build an earnings agent the hard way: scrape transcripts, chunk them, stuff them into a vector store, write retrieval glue, and pray your prompt engineering holds. That's a lot of plumbing for something that goes stale the moment a new quarter drops.

The Model Context Protocol (MCP) flips the model. Instead of pre-baking data into a pipeline, you expose a set of tools and let the model decide which ones to call, in what order, given the question. Claude reads the tool descriptions, reasons about the task, and orchestrates the calls itself. You write the intent; the model writes the plan.

That's the key property for research: the workflow isn't fixed. "Did guidance change?" needs a different tool sequence than "which analysts pushed back on the buyback?" With MCP, you don't encode those paths. The agent picks them at runtime. The EarningsCalls MCP server gives Claude live, structured access to the transcript corpus so it never works from stale scraped copies.

The building blocks

You need three things:

  1. An account and a connector URL. In the dashboard, go to Connectors, click Generate, and you'll get a URL shaped like https://earningscalls.dev/u/mct_xxxx/mcp. That URL is your authenticated endpoint into the corpus: 246,000+ transcripts across 12,000+ companies, 70 countries, 170+ exchanges, and all 11 GICS sectors, going back to 2020.

  2. A client that speaks MCP. Claude Code is the fastest path. Wire it up with one command:

    claude mcp add --transport http earningscalls "https://earningscalls.dev/u/mct_xxxx/mcp"

    If you're building something more bespoke, the Claude Agent SDK lets you register the same HTTP MCP server programmatically and drive it from your own code.

  3. The tools themselves. The server exposes roughly 13 tools. The ones you'll lean on for research:

    • search_transcripts — full-text search across the whole corpus (11M+ speaker segments)
    • get_transcript / get_earnings_call — pull a full call
    • get_speaker_segments — grab statements filtered by role (executive, analyst, operator, attendee, shareholder)
    • list_calls_by_ticker and get_latest_call_for_ticker — navigate a single company's history
    • list_upcoming_earnings — see what's on the calendar
    • get_dataset_stats, get_company_by_name, list_sectors / list_industries — lookups and coverage checks

That's the whole kit. No embeddings to manage, no ETL job to babysit.

A worked example: a one-page earnings debrief

Let's build the flagship use case: point the agent at a ticker and get back a one-page debrief. In Claude Code, this is a single instruction. The agent handles the rest.

You are an earnings research agent. For ticker NVDA, produce a one-page debrief of the most recent quarter. Steps: (1) find the latest call, (2) pull the prepared remarks and summarize the top three themes management led with, (3) pull the analyst Q&A and surface the two sharpest pushback questions plus how management answered, (4) flag any change in forward guidance versus the prior quarter. Keep it under 400 words, use bullet points, and cite the speaker for every quote.

Behind that prompt, Claude will typically call get_latest_call_for_ticker to locate the call, get_transcript or get_speaker_segments (filtered to executive) for the prepared remarks, get_speaker_segments (filtered to analyst) for the Q&A, and list_calls_by_ticker to reach back a quarter for the guidance comparison. Three to five tool calls, and you have a brief.

The role filter on get_speaker_segments is what makes this clean. You're not asking Claude to eyeball who's an analyst and who's the operator — the corpus already tags every one of its 11M+ segments by role, so "surface analyst pushback" becomes a precise query instead of a guess.

Multi-step and agentic patterns

The debrief above is the simplest shape. Once you're comfortable, the interesting patterns are the multi-step ones where the agent chains tools and reasons across the results.

Search then fetch then compare. This is the workhorse loop:

Across the last four quarters for SHOP, track how often and in what tone management discussed "take rate." Use search to find the relevant segments in each call, pull the surrounding context, and give me a quarter-over-quarter narrative of how the framing shifted. Note any quarter where they stopped volunteering a specific number.

Here the agent runs search_transcripts (or a per-ticker search) once per quarter, fetches the matching segments, and then does the actual analytical work — comparing framing across time — in a single synthesis pass. No single tool does "compare quarters." The agent composes it.

Cross-company comparison. Swap the axis from time to peers:

Compare how AMD and INTC each characterized data-center demand on their most recent calls. Pull both, contrast the executive commentary, and tell me who sounded more confident and why, with quotes.

Themes across a sector. Because coverage spans all 11 GICS sectors and 170+ exchanges, you can widen the net: "search the last quarter of semiconductor calls for mentions of 'inventory correction' and summarize the consensus." The agent fans out searches and rolls up the findings.

The pattern is always the same: search to locate, fetch to read, then let the model do the comparison and writing. You're not orchestrating that by hand — you're describing the outcome and trusting the agent to sequence it.

Scheduling it: recurring runs

A debrief you run once is a tool. A debrief that runs itself is a system.

The natural next step is to schedule the agent so it fires on a cadence — for example, a nightly job that checks list_upcoming_earnings, and when one of your watched tickers reported in the last 24 hours, runs the one-page debrief and drops it in your inbox or a Slack channel.

You can wire this with a plain cron job that shells out to Claude Code with your debrief prompt, or build it into a longer-running Agent SDK service. The corpus updates as new calls land, so a scheduled agent always works against fresh data. For a deeper build-out of this pattern, see automated research workflows with Claude Code and the EarningsCalls MCP, and for the event-driven side, real-time earnings call alerts with an MCP agent.

Cost and quota notes

The pricing model is simple and worth internalizing before you turn on a scheduler.

Do the arithmetic on your use case. At 3–5 calls per debrief, Pro's 5,000 requests covers on the order of 1,000–1,600 debriefs a month — plenty for a personal watchlist or a small newsletter. If you're running a scheduled agent across dozens of tickers every earnings season, or fanning out sector-wide searches, Ultra's headroom is the safer choice. Keep sessions tight: a well-scoped prompt that pulls exactly the segments it needs beats one that fetches whole transcripts it won't use.

If your goal is broad screening rather than deep single-stock work, the market-wide screening with MCP tools approach is worth reading — it uses the same tools with a different quota profile.

Full tool signatures, parameters, and role values are in the docs.

Ship one this week

An earnings research agent isn't a big project. It's a connector URL, one claude mcp add command, and a well-written debrief prompt. Start with the one-page debrief for a single ticker you already follow, confirm the output is something you'd actually read, then graduate to cross-quarter comparisons and a nightly schedule.

Generate your connector in the dashboard and pick a plan to get building.