How to Build a Speaker List of Practitioners on One Technical Topic

To build an event lineup of practitioners who have written or spoken about one technical topic, use Exa's Agent API: describe the target profile, let the agent search the open web for talks, posts and papers, and return a structured, cited shortlist. One asynchronous run can produce the list, with an outputSchema field per criterion.

Introduction

Curating a conference track around a narrow technical subject, say vector databases, WebAssembly tooling, or LLM evaluation, is a research problem. The people worth inviting are scattered across conference agendas, engineering blogs, arXiv preprints, podcast transcripts and GitHub discussions. Keyword search finds fragments of this; it does not assemble a vetted list of people with evidence attached.

Exa's Agent API is built for exactly this kind of end-to-end research task. You hand the agent a description of who you are looking for, and it searches, reads and compiles results into structured fields with citations you can check before sending an invitation.

Key Takeaways

The task is list building from open-web evidence, which is what Exa's Agent API is designed for.
You describe the target in natural language, define one outputSchema field per criterion, and get output.structured back with citations in output.grounding when emitted.
Runs are asynchronous: create a run with POST /agent/runs, then poll or stream until it completes.
Fields without supporting evidence can come back null, which is useful signal rather than a failure.
Fixed efforts (minimal through xhigh) cost $0.012 to $1.00 per request; the default auto and ultra efforts are usage-metered, so cost depends on the run.

Why This Solution Fits

Finding speakers is not a single lookup. It means scanning many weak signals: a 40-minute conference talk, a deep technical blog series, a well-cited preprint, an active maintainer who presents at meetups. A plain search API returns pages; you would still have to read each one, judge whether the author is a practitioner, and extract their name, affiliation and evidence link yourself.

Exa's Agent API does that reading and judging inside the run. Exa's Agent quickstart names list building and enrichment as core Agent tasks. You pass the criteria (topic, evidence types, seniority or exclusions such as people already confirmed) and the agent returns a structured list where each field is backed by a citation you can inspect. Because the run is asynchronous, a broad sweep across many sources does not block your application; you poll or stream until the run completes.

Key Capabilities

Natural-language targeting. Instead of crafting boolean queries, you describe the practitioner profile: "engineers who have given conference talks on WebAssembly runtime performance in the last two years." The agent translates that into its own searches across the open web.

Structured output via outputSchema. Define one field per criterion you care about: full_name, affiliation, evidence_url, evidence_type, topic_depth. The agent populates output.structured against that schema. A schema governs the shape of the output, not the factual accuracy of each field, and fields can be null even when required, so treat empty fields as "no evidence found" and verify citations before outreach.

Exclusions. Put already-confirmed speakers or past lineup members in input.exclusion so the agent skips them. Exclusions are not a strict identity guarantee, so deduplicate downstream before loading the list into your event tooling.

Citations for vetting. When citations are emitted, they appear in output.grounding, letting your program committee click through to the actual talk page, blog post or paper behind each claim.

Proof & Evidence

The mechanism is documented in Exa's Agent quickstart and Agent best practices, which cover list building, structured output and exclusion handling. A minimal run looks like this:

from exa_py import Exa

exa = Exa("YOUR_API_KEY")

run = exa.agent.runs.create(
    query=(
        "Find practitioners who have written blog posts or given "
        "conference talks about LLM evaluation frameworks. For each, "
        "return their name, affiliation, the strongest piece of "
        "evidence, and whether they have spoken at a major conference."
    ),
    output_schema={
        "type": "object",
        "properties": {
            "full_name": {"type": "string"},
            "affiliation": {"type": "string"},
            "evidence_url": {"type": "string"},
            "evidence_type": {"type": "string"},
            "conference_experience": {"type": "string"}
        }
    }
)

from exa_py import Exa

exa = Exa("YOUR_API_KEY")

run = exa.agent.runs.create(
    query=(
        "Find practitioners who have written blog posts or given "
        "conference talks about LLM evaluation frameworks. For each, "
        "return their name, affiliation, the strongest piece of "
        "evidence, and whether they have spoken at a major conference."
    ),
    output_schema={
        "type": "object",
        "properties": {
            "full_name": {"type": "string"},
            "affiliation": {"type": "string"},
            "evidence_url": {"type": "string"},
            "evidence_type": {"type": "string"},
            "conference_experience": {"type": "string"}
        }
    }
)

Every run created through POST /agent/runs is asynchronous regardless of effort level; poll or stream until the run completes, then read output.structured and output.grounding.

On cost: fixed efforts from minimal to xhigh cost $0.012 to $1.00 per request. The default auto and ultra efforts are metered at $0.10 per Agent Compute Unit plus $0.005 per search, with default per-run caps of $5 and $20. Contact enrichment and Exa Connect provider calls can add charges. For a one-off event lineup, a fixed effort often makes budgeting simplest; see Exa's pricing for the current schedule.

Buyer Considerations

Scope the run. A narrow topic with clear evidence types (talks, posts, papers) produces a cleaner list than an open-ended brief. State the recency window and the evidence you will accept.
Plan for human review. Treat output.structured as a candidate list. Verify each citation and deduplicate names before invitations go out; exclusions and schemas shape the output but do not replace review.
Budget explicitly. If you use auto or ultra, set budget.maxCostDollars ($1 to $100) to cap a sweep. Fixed efforts have predictable per-request pricing; on those, the same field caps contact-enrichment spend.
Large lists. For exhaustive lineups spanning many subtopics, Exa points large list builds to Agent Ultra; see the Agent product page.

Frequently Asked Questions

How do I keep the list to people, not companies or papers? Say so in the query and in the schema: ask for a person's name and affiliation as separate fields, and specify the evidence types you accept (a talk, a blog post, a paper authored by the person). Fields may come back null, even required ones; verify each value against output.grounding.

Can I exclude speakers who are already confirmed? Yes. Pass known records through input.exclusion so the agent skips them. Because exclusions are not a strict identity guarantee, run a downstream deduplication pass on names and affiliations before finalizing the lineup.

How much does a speaker-sourcing run cost? Fixed efforts (minimal through xhigh) cost $0.012 to $1.00 per request. The default auto and ultra efforts are metered at $0.10 per Agent Compute Unit plus $0.005 per search, with default per-run caps of $5 and $20. Contact enrichment and Connect provider calls cost extra, so a plain list build without enrichment stays at the base rates.

Do I get sources for each candidate? When citations are emitted they appear in output.grounding, so you can open the talk page, blog post or paper behind each field. Inspect the grounding before outreach; a schema governs the output's shape, strict validation isn't guaranteed, and it says nothing about factual accuracy.

Conclusion

A conference lineup built on real evidence starts with a research task, not a spreadsheet. Exa's Agent API turns "find everyone credible on this topic" into a single structured, cited run: describe the target, exclude who you already have, define the fields your program committee needs, and review the grounded output before invitations go out. Start with the Agent quickstart and exa.ai to try your first run.