This publish is co written by Ishan Goswami and Nitya Sridhar from Exa.
If you’re constructing internet search-enabled AI brokers for analysis, fact-checking, or aggressive intelligence, entry to present and dependable data is essential. Most general-purpose search APIs are usually not designed for agent workflows. They return HTML-heavy pages and quick snippets optimized for human shopping, not structured information that an agent can instantly devour. Consequently, builders typically have to construct extra layers, customized crawlers, parsers, and rating logic, to rework this content material into one thing usable inside an agent workflow.
The Exa integration for the Strands Brokers SDK addresses this hole with an AI-native search and retrieval layer constructed instantly into the software interface. Exa delivers clear, structured content material formatted for direct use in LLM context home windows, with out requiring post-processing to strip markup or reformat output. Mixed with the Strands Brokers SDK’s model-driven structure, the place the mannequin decides when to invoke instruments and the right way to use their outputs, brokers can draw real-time internet data into their reasoning loop.
In apply, your agent accesses this integration by two instruments: exa_search, which performs semantic search with assist for classes like information, analysis papers, and repositories, and exa_get_contents, which retrieves full content material from chosen URLs. On this publish, you’ll learn to arrange the Exa integration in Strands Brokers, perceive the 2 core instruments it exposes, and stroll by real-world use circumstances that present how brokers use internet search to finish multi-step duties.
Strands Brokers
The Strands Brokers SDK is an open supply framework from AWS for constructing AI brokers utilizing a model-driven strategy. Fairly than writing hard-coded workflows that dictate each step, builders present a mannequin, a system immediate, and an inventory of instruments. The mannequin itself decides what to do subsequent: which instruments to name, in what order, and when the duty is completed. On the core of Strands Brokers is the agent loop. On every iteration, the mannequin receives the total dialog historical past, together with each prior software name and its consequence. If the mannequin wants extra data, it requests a software; Strands Brokers executes it and feeds the consequence again. The loop continues till the mannequin produces a last reply. This accumulation of context throughout iterations is what makes brokers able to tackling multi-step duties that transcend what a single LLM name can deal with. The Strands Brokers SDK ships with over 40 pre-built instruments protecting file I/O, shell execution, internet search, AWS APIs, reminiscence, code execution, and extra. It additionally helps Mannequin Context Protocol (MCP), so instruments uncovered by MCP servers can be found to an agent with out extra integration work. Including new instruments, together with the Exa internet search instruments, follows the identical sample: drop them into the `instruments=[]` checklist and the mannequin learns the right way to use them from their signatures.
Exa
Exa is a web-scale search engine constructed particularly for LLMs and AI brokers. Exa is a search engine that understands the which means of a question, not simply its key phrases. A question like “startups constructing local weather options” returns precise local weather startups, even when these pages by no means use that precise phrase. The mannequin matches on semantic similarity, not string overlap. Outcomes come again as clear, structured content material with no advertisements or search engine marketing noise, prepared for an LLM to devour instantly.
Strands Brokers and Exa: Integration overview
The Exa integration is on the market by the strands-agents-tools package deal. It provides your agent two capabilities: looking out the net for related content material and extracting full-page textual content from particular URLs. The diagram beneath visualizes the deep analysis assistant instance which can discuss in depth within the later a part of this weblog.
Each are optimized for AI consumption, returning structured content material that your agent can purpose over instantly.
- exa_search: Search the net utilizing a number of modes together with auto, quick, and deep. Your agent can refine outcomes with filters for class, area, date, and textual content content material.
- exa_get_contents: Retrieve full-page content material from URLs your agent has found whether or not from a earlier search or from its personal reasoning. The software checks for cached outcomes first to hurry up repeated requests. If recent content material is required, it could possibly mechanically fall again to dwell crawling to retrieve essentially the most up-to-date model of the web page.
Looking the net with exa_search
The exa_search software provides your agent management over internet search that goes past a fundamental question string. The software helps 4 search modes. The default mode, auto, is the beneficial place to begin for many use circumstances.
- On the spot (~200ms) – Designed for real-time purposes akin to autocomplete, dwell recommendations, and voice brokers.
- Quick (~450ms) – Optimized for pace whereas nonetheless accessing Exa’s high quality index. Appropriate for agentic workflows the place your agent makes dozens of search calls.
- Auto (~1s) [Recommended] – Balanced latency with high-quality outcomes. Really helpful for many use circumstances.
- Deep (~3-6s) – Runs parallel searches throughout question variations for optimum protection. Finest for analysis duties the place completeness issues.
Past search modes, exa_search provides your agent fine-grained management over how outcomes are filtered and scoped. You may slim a search to particular content material classes akin to information articles, firm web sites, GitHub repositories, PDFs, folks profiles, or monetary studies. Class filtering is best when your agent already is aware of what sort of supply it wants. For instance, filtering to analysis papers when the question is technical, or to information sources when recency is the precedence. You can even request content material and summaries in keeping with search outcomes, all in a single name:
agent.software.exa_search( question=”latest advances in AI security analysis”, num_results=10, abstract={“question”: “key analysis areas and findings”}) .
The response contains titles, URLs, and a synthesized abstract of every consequence centered on the question you specified. Your agent can construct foundational understanding of a subject with out studying each web page in full.
Extracting content material with exa_get_contents
As soon as your agent has discovered related URLs, whether or not from a earlier search or from its personal reasoning, the exa_get_contents software retrieves the full-page content material. You move it an inventory of URLs, and it returns the extracted textual content, prepared for the agent to course of.Exa maintains a content material cache that serves outcomes immediately for pages it has already crawled. For pages that aren’t within the cache, or when your agent wants essentially the most present model of a web page, the software helps dwell crawling. You management this habits with livecrawl modes. A configurable timeout controls how lengthy to attend for dwell crawls to finish.You can even management how a lot textual content is returned. For instance, to retrieve as much as 5,000 characters of plain textual content from a web page:
agent.software.exa_get_contents(urls=[“https://example.com/blog-post”], spotlight={“maxCharacters”: 5000})
Stipulations
To comply with together with the examples on this publish, you want:
- Python 3.10 or later
- An AWS account with Amazon Bedrock entry
- An Exa API key
- The strands-agents and strands-agents-tools packages put in:
- pip set up strands-agents strands-agents-tools
Setup
The Exa instruments comply with the identical sample as each different software within the Strands Brokers framework, so you probably have used different Strands instruments, the expertise is similar.The Strands Brokers SDK features a library of pre-built instruments protecting file operations, internet search, code execution, AWS companies, reminiscence administration, and extra. The Exa instruments are a part of this library. Import them and move them to the Agent constructor by the `instruments` parameter. The agent’s underlying LLM then decides when to name every software as a part of its reasoning loop. As a result of the combination talks to the Exa REST API instantly, you don’t want to put in or handle a separate SDK. The one new dependency is the `strands-agents-tools` package deal.To make use of Exa with Strands Brokers, comply with these steps:
1. Set your Exa API key
Exa requires an API key for authenticated entry. Set the EXA_API_KEY setting variable along with your key earlier than working your agent. You may acquire a key from the Exa dashboard:
export EXA_API_KEY=”your_exa_api_key_here”
2. Import and register the instruments
In your agent code, import exa_search and exa_get_contents from strands_tools.exa and embrace them within the agent’s software checklist:
from strands import Agent
from strands_tools.exa import exa_search, exa_get_contents
agent = Agent(instruments=[exa_search, exa_get_contents])
3. Invoke your agent
As soon as the instruments are registered, your agent can interleave search and content material extraction naturally as a part of its reasoning movement:
response = agent( “Seek for the latest developments in AI brokers and supply a concise abstract of key developments”)
With the agent arrange, you can begin utilizing the Exa instruments for various search situations.
Instance: Constructing a Deep Analysis Agent with Exa
To see how each instruments work collectively, the next instance builds a deep analysis assistant that demonstrates each Exa instruments in a multi-step workflow. Given a analysis query, the agent runs 4 focused searches throughout completely different supply varieties, extracts full content material from essentially the most promising outcomes, and synthesizes every little thing right into a structured analysis transient. The whole workflow executes inside a single agent invocation, with a number of software calls occurring as a part of the reasoning loop.The important thing design perception is that completely different supply varieties require completely different search parameters, however not completely different instruments. The 2 Exa instruments are reused all through the workflow with completely different parameter configurations at every step: class to focus on information, PDFs, or repositories; date filters for recency; JSON schemas for structured extraction; and dwell crawling for freshness.
Get began
- Join an Exa API key on the Exa dashboard
- Clone the pattern repository and run the deep analysis assistant
- Modify the system immediate to focus on your area: swap class filters, date ranges, and JSON schemas to match your use case
Organising the agent
The setup takes a mannequin, a system immediate, and the 2 Exa instruments:
from strands import Agent
from strands.fashions.bedrock import BedrockModel
from strands_tools.exa import exa_search, exa_get_contents
def create_research_agent() -> Agent:
mannequin = BedrockModel(
model_id=”us.anthropic.claude-sonnet-4-6″,
region_name=”us-west-2″,
max_tokens=20000,
)
return Agent(
mannequin=mannequin,
system_prompt=load_system_prompt(),
instruments=[exa_search, exa_get_contents],
)
A system immediate defines the analysis workflow, guiding the agent by six steps: 4 focused searches throughout completely different supply varieties, a deep-dive content material extraction, and a last synthesis move. The agent decides when and the right way to name every software, the right way to interpret the outcomes, and when to maneuver to the subsequent step as a part of its reasoning loop. The 6-step analysis workflowEach step instructs the agent to name the Exa instruments with completely different parameters tuned for that type of content material.
Step 1: Overview search – A broad sweep utilizing auto mode builds foundational understanding. The system immediate instructs the agent to name `exa_search` with these parameters.
– kind: “auto”
– num_results: 5
– textual content: {“maxCharacters”: 2000}
– highlights: {“maxCharacters”: 4000}
– abstract: {“question”: “What are the important thing ideas, details, and necessary particulars?”}
– subpages: 2
– subpage_target: [“overview”, “about”, “introduction”]
– max_age_hours: 168
Step 2: Information search – The main target narrows to information sources inside a 30-day date window. The date boundary is computed in Python and injected into the immediate. The max_age_hours units the utmost acceptable age (in hours) for cached content material.
– class: “information”
– num_results: 5
– start_published_date:
– textual content: {“maxCharacters”: 1500}
– abstract: {“question”: “What are the important thing bulletins, developments, and information?”}
– max_age_hours: 24
Step 3: Analysis papers – For tutorial depth, the search targets the analysis paper class with a guided question to extract key findings, methodology, and conclusions as concise excerpts.
– class: “analysis paper”
– num_results: 5
– textual content: {“maxCharacters”: 2000}
– abstract: {
“question”: “Extract the analysis findings, methodology, and conclusions”,
“schema”: {
“kind”: “object”,
“properties”: {
“title”: {“kind”: “string”, “description”: “Paper title”},
“main_findings”: {“kind”: “string”, “description”: “Key findings and outcomes”},
“methodology”: {“kind”: “string”, “description”: “Analysis methodology used”},
“conclusions”: {“kind”: “string”, “description”: “Primary conclusions”}
},
“required”: [“main_findings”, “conclusions”]
}
}
Step 4: GitHub tasks – Open supply implementations floor by the github class.
– class: “github”
– num_results: 5
– highlights: {“maxCharacters”: 4000}
Step 5: Deep dive – The agent switches from discovery to extraction. The 2 or three most promising URLs from earlier steps get their full content material pulled with exa_get_contents. This step makes use of compelled dwell crawling (“at all times” as a substitute of “fallback”) for recent content material, a better character restrict (4000) for complete extraction, and subpage crawling to comply with hyperlinks to references, citations, and methodology pages.
– urls: <2-3 most dear URLs from earlier searches>
– textual content: {“maxCharacters”: 4000}
– highlights: {“maxCharacters”: 4000}
– abstract: {“question”: “Extract all necessary particulars, insights, and actionable data”}
– subpages: 3
– subpage_target: [“references”, “citations”, “bibliography”, “methodology”]
– max_age_hours: 0
Step 6: Synthesis – No instruments are known as on this last step. Every part gathered from the earlier steps feeds right into a structured analysis transient with sections for an govt abstract, matter overview, latest developments, key analysis and papers, instruments and implementations, deep dive insights, and a whole checklist of sources with URLs.
The multi-step workflow affords a number of benefits over a single search name or a fundamental search API wrapper:
- Grounded solutions – Each declare within the last transient traces again to a supply URL, lowering hallucination.
- Environment friendly token utilization – Summaries at search and extraction time maintain the content material concise, so the LLM works with distilled data slightly than uncooked web page dumps.
- Autonomous depth – The agent iterates throughout supply varieties (information, papers, code repositories, full pages) with out human steering, protecting floor {that a} single search couldn’t.
Tracing with Amazon Bedrock AgentCore Observability
A 6-step pipeline with a number of software calls is tough to debug with out structured tracing. Amazon Bedrock AgentCore Observability, constructed on OpenTelemetry, devices the total agent run with minimal code modifications. Every software name and LLM invocation turns into a span with parent-child relationships.Within the CloudWatch GenAI Observability Dashboard, every analysis run seems as a full hint. You may see the common span latency throughout completely different spans within the agent.
You may drill into particular person spans to examine:
- Device name parameters per exa_search or exa_get_contents invocation, verifying the agent used the proper class, date vary, and content material limits at every step
- Latency per step, figuring out whether or not the information search or the deep dive extraction is the bottleneck
- Token consumption by LLM invocation, exhibiting token distribution throughout search steps versus synthesis
Agentic workflows are non-deterministic. The identical question can produce completely different search outcomes, completely different URL choices for the deep dive, and completely different synthesis outputs. Hint information turns debugging from guesswork into inspection. An instance of the ultimate response and the analysis transient is proven within the last step as within the screenshot beneath –
Finest practices for utilizing Exa instruments
As you combine Exa instruments into your brokers, just a few patterns might help you optimize for high quality, latency, and value. The next suggestions will allow you to get essentially the most out of the Exa instruments in your agent workflows. For extra on search varieties, content material modes, and superior filtering, see the Exa greatest practices documentation.
- Begin with auto and alter from there: The auto search kind handles most queries properly. Change to deep for analysis duties the place lacking a related supply is expensive, and to quick or immediate when the agent makes many sequential searches and cumulative latency issues greater than per-query completeness.
- Management content material dimension to handle token budgets: Set maxCharacters on “highlights” area (the place default maxCharacters is 4,000).
Clear up sources
This walkthrough doesn’t create any persistent AWS sources. In the event you not want your Exa API key, revoke it from the Exa dashboard
Conclusion
The Strands Brokers SDK and Exa present a path to constructing AI brokers which might be grounded in present, correct internet data. Exa’s search delivers semantic understanding, class filtering narrows outcomes to the best content material kind, AI summaries with JSON schemas return precisely the construction your agent wants, and dwell crawling offers freshness. The Strands Brokers integration exposes these capabilities by two instruments and some strains of setup code.
Because the deep analysis assistant demonstrates, you possibly can construct a multi-step analysis agent that searches throughout information, educational papers, and code repositories, extracts full web page content material from the most effective outcomes, and synthesizes every little thing right into a grounded transient, all pushed by a single system immediate. The agent targets supply varieties with class filters, controls recency with date ranges, shapes output with JSON schemas and manages freshness with dwell crawling. You may check search, contents, and reply endpoints instantly from the Exa dashboard earlier than wiring them into your agent. The whole workflow is traceable by Amazon Bedrock AgentCore Observability, turning non-deterministic agent habits into inspectable, debuggable spans. The sample applies past analysis to aggressive intelligence, technical assist, market evaluation, and different domains the place brokers want real-time internet data.Attempt the deep analysis assistant pattern with your personal analysis questions. Get your Exa API key to start out constructing, discover the Amazon Bedrock documentation to be taught extra in regards to the underlying platform, and share your suggestions on the Strands Brokers GitHub repository.
In regards to the authors
Madhu Samhitha Vangara is a Worldwide GenAI Specialist Answer Architect at AWS, specializing in Agentic AI GTM for Amazon Bedrock AgentCore and Strands Brokers. She brings a deep understanding of enterprise enterprise worth, with earlier trade expertise in Juniper Networks, VMware, Barclays, and IGCAR. She interprets rising AI capabilities and analysis into measurable outcomes for purchasers. She is a speaker at AI conferences like AWS re:Invent, NVIDIA GTC, AI Summit and others the place she makes a speciality of multi-agent techniques, agent observability, LLMs, accomplice ecosystems, and production-grade Agentic AI. She holds a grasp’s in Laptop Science from UMass Amherst. Exterior work, she’s a educated Indian classical dancer and an artwork fanatic.
Manoj Selvakumar is a GenAI Specialist Options Architect at AWS specializing in agentic AI techniques. He helps startups and enterprises architect manufacturing AI brokers utilizing the Strands Brokers SDK and Amazon Bedrock AgentCore, with experience in multi-agent orchestration, context engineering, and inference optimization. His work with prospects spans long-running job patterns, reminiscence administration, and manufacturing scaling throughout distributed deployments. He drives technical adoption and ecosystem progress for Strands Brokers, by open-source samples, accomplice integrations, and group enablement.
Asheesh Goja is CTO for superintelligence prospects at Lambda. Beforehand, he was a Principal Gen AI Options Architect at AWS. Earlier, he labored at Cisco and UPS, main initiatives to speed up adoption of rising applied sciences. His experience spans ideation, co-design, incubation, and enterprise product improvement. He holds a broad portfolio of {hardware} and software program patents, together with a real-time C++ DSL, IoT gadgets, and Laptop Imaginative and prescient and Edge AI prototypes. An lively contributor to Generative AI and Edge AI, he shares insights by tech blogs and as a speaker at trade conferences and boards.
Mani Khanuja is a Technical AI Chief and Principal Generative AI Options Architect at AWS with 20+ years of expertise constructing AI platforms from scratch and driving enterprise AI technique. She works instantly with prospects to construct their Generative AI technique, from structure to manufacturing deployment at scale. Her present focus is scaling autonomous AI brokers safely and effectively: creating stateful, memory-driven brokers with personalization, advancing AI governance frameworks, and translating cutting-edge analysis into real-world enterprise techniques. She is the creator of Utilized Machine Studying and Excessive-Efficiency Computing on AWS. She can also be a acknowledged technical speaker at Re:Invent, Grace Hopper Celebration, AI Engineer Summit, and AWS Summits worldwide. She resides in Seal Seashore, California, the place she stays lively with lengthy runs alongside the coast.
Ishan Goswami is the Founding DevRel Engineer at Exa, the place he leads developer relations. He builds and ships integrations, open-source demo apps, MCP servers, and plugins that make Exa straightforward to make use of inside any AI app or workflow. Earlier than Exa, Ishan co-founded a text-to-video startup. He has constructed apps which have been utilized by tens of millions of individuals and open supply tasks with hundreds of GitHub stars.
Nitya Sridhar is the Head of Advertising at Exa, the place she leads product launches, technical blogs, progress campaigns, and rather more. She works intently with engineering and GTM to convey Exa to builders and enterprises all over the world, with a give attention to clear technical storytelling and turning new product options into tales the group can use.
