top of page

Amazon Bedrock AgentCore Web Search API Removes the Gateway Requirement

4 days ago
11 min read

Amazon has introduced the AgentCore Web Search API, letting applications search its existing web index without first creating an AgentCore Gateway. The change gives developers a direct route to search results while leaving shared source policies with the gateway or application. That distinction matters: simpler access changes who owns the surrounding controls.

The new interface serves applications, custom agent loops, and data pipelines through familiar AWS credentials. An agent loop is application code that repeatedly lets a model choose actions and process their results. Previously, AgentCore’s web search route required a gateway and a configured search target. Developers consumed that tool through Model Context Protocol, or MCP, a standard for connecting AI applications to external tools.

AWS still recommends AgentCore Gateway for most agentic workloads. Its November 11 announcement presents direct access as a complementary option for software that already manages its own execution. The central choice is therefore architectural: should search policies live in a shared service, or should each application enforce them? The release removes a setup requirement without removing that decision.

What the AgentCore Web Search API actually changes

The release changes access to Amazon’s search infrastructure, rather than introducing Amazon’s first web search capability.

AWS’s Web Search API announcement describes a standalone operation that returns results directly to calling code. Developers can use AWS software development kits, which provide language-specific service clients, or the AWS Command Line Interface.

The operation is called InvokeWebSearch. Applications authorize requests through AWS Identity and Access Management, or IAM, the service that defines permissions for AWS identities. Existing AWS credentials sign the request. Developers do not need to provision a gateway or search target before making that call.

AWS says the direct interface searches the same Amazon-operated index used by its gateway connector. The announcement does not establish a new search-quality advantage over that existing route. Its clearest contribution is removing the intermediary when an application needs results rather than a discoverable agent tool.

That makes the release relevant beyond conversational assistants. Consider an existing application that periodically collects public product announcements. Its scheduler already determines when work runs, its database stores findings, and its code decides what users see. Adding an agent gateway solely to retrieve search results introduces another component for that team to operate.

The direct interface lets that application retain its current structure. Search becomes a service call within an established process. The same logic applies to a monitoring job or a content enrichment system. Neither needs autonomous decision-making simply because its inputs come from the web.

This distinction also changes how developers should interpret the phrase “no resources to create.” It describes access to the search operation. A production application still needs an execution environment, permissions, error handling, and somewhere to send its output. Optional networking and logging configurations also remain separate choices.

The relevant comparison is therefore between integration paths. A gateway organizes access to tools across clients. A direct API, an interface that software calls programmatically, returns data inside an application’s existing flow. Choosing between them should start with the software consuming the result, rather than enthusiasm for either architecture.

For teams already using Gateway successfully, this announcement alone supplies no reason to migrate. The search backend remains shared. A migration would need another justification, such as simplifying an application that no longer needs MCP or moving execution controls into existing code.

For teams that previously considered AgentCore search too dependent on agent infrastructure, the release changes that calculation. They can now evaluate the search service separately from the gateway architecture.

Application owners gain control, and inherit the decisions

Direct search gives application developers more control over execution, while making their ownership of source policy more explicit.

The practical pressure falls on teams deciding where to place rules. A platform group serving many agents has different requirements from a developer adding search to an established application. The former needs consistency across clients. The latter often needs a predictable dependency inside code it already maintains.

AWS’s API and Gateway guidance makes the boundary concrete. Direct requests carry their own domain filters. The gateway connector can additionally apply source lists configured on its target, outside the calling agent’s view. The direct API authorizes callers with IAM; Gateway also supports token-based caller authorization.

Those differences separate permission to search from permission to choose sources. An application identity can be authorized to invoke search without that fact establishing an organization-wide list of acceptable domains. Source restrictions still need an enforcement point.

An illustrative engineering assistant makes the distinction easier to see. Its developers might permit searches across vendor documentation while excluding discussion forums from release summaries. If those rules live in application code, that team must maintain them as the assistant changes. If several assistants share the policy, centralized administration becomes more attractive.

Neither arrangement is inherently superior. Local rules can fit an application whose requirements differ from everyone else’s. Shared rules can reduce drift when many teams need the same restrictions. The tradeoff concerns ownership and consistency, rather than a simple contest between flexibility and safety.

The same reasoning applies to retries, which repeat failed requests, and caching, which reuses previous results. Application teams can place those decisions alongside their existing reliability controls. They also become responsible for ensuring those controls reflect how search behaves within the broader workflow.

For example, reusing yesterday’s response might suit a background research archive. It would be less appropriate for a screen asking what changed this morning. A cache can reduce repeated work while also undermining freshness if its lifetime ignores the user’s question.

AgentCore API vs Gateway therefore becomes a question about operational boundaries. Where should source restrictions change? Who approves those changes? Which component controls search frequency? Which team investigates an answer that cites an unexpected site?

These questions matter before an application reaches large scale. A prototype often has an obvious owner and a narrow purpose. As other teams adopt it, assumptions about trusted sources and acceptable reuse can diverge. A direct connection makes those assumptions easier to implement locally, but no easier to reconcile across organizations.

AWS’s decision gives developers another place to draw that boundary. It does not eliminate the need to draw it deliberately.

Search results give developers evidence to inspect

The value of direct retrieval is that applications can examine evidence before asking a model to turn it into an answer.

The request and response documentation describes ranked results containing text extracts. Titles, URLs, and publication timestamps are optional. Requests accept queries of up to 200 characters and return up to 25 results, with domain and publication-time filters available.

These details describe a bounded retrieval operation. The application receives candidate material, rather than a guarantee that a question has been answered completely. Returning a ranked list also leaves the caller responsible for deciding what evidence is sufficient.

Optional metadata creates an immediate product decision. A result without a publication timestamp might still contain useful background. It cannot, by itself, establish that an announcement belongs inside a narrowly defined reporting window. The application needs a rule for that uncertainty.

Likewise, an extract without a URL presents a different problem from an extract with a traceable source. If users expect to inspect supporting evidence, the application must decide whether incomplete attribution disqualifies a result. Quietly treating every result as equally usable would conceal that distinction.

Date filtering also requires care. The documentation defines inclusive timestamp boundaries and warns that a date without a time means midnight at its start. An application translating a user’s calendar selection must preserve the intended interval.

That is a small interface detail with potentially visible consequences. A user selecting a reporting day expects the entire day. An incorrectly translated endpoint can exclude material while leaving the request technically valid. The resulting summary might look polished despite using an unintended evidence window.

Domain filters answer another specific question: where results are allowed to originate. They do not establish whether a particular page supports the model’s conclusion. A trusted publisher can host background material that is irrelevant to the requested event.

The same distinction separates a search extract from a completed fact check. An extract can identify promising evidence. A consequential conclusion might require examining the underlying source, checking its context, or comparing it with another authoritative record.

Microsoft provides a useful comparison through its Bing grounding tools. Grounding means supplying external evidence to a model before it answers. Microsoft documents a path where developers receive generated responses with citations rather than access to raw returned content.

That comparison highlights an architectural difference, without establishing a quality ranking. Some products prioritize a cited answer inside an agent service. Others need search material they can inspect and process independently. Amazon’s direct interface addresses the latter requirement.

For buyers, the evaluation question should match that distinction. Assessing answer fluency alone would miss the reason to choose an inspectable retrieval interface. The more relevant question is whether the returned material supports the application’s own evidence rules.

A dependency watcher shows where search stops

AWS’s worked example places verification in application code, illustrating why retrieval and validated reporting remain separate tasks.

In its daily dependency watcher, AWS describes a security workflow built with LangGraph, a framework for coordinating agent execution. The example researches software dependencies, applies fixed search rules, checks findings against returned sources, and suppresses previously reported items.

The significant design choice is the separation of responsibilities. The model chooses searches and proposes findings. Code controls constraints and checks whether the evidence meets specific conditions. Search access supplies material for that process.

AWS also states the example’s limits. Its checks do not establish severity, exploitation status, affected versions, or recommended action. Matching a finding to retrieved evidence is therefore narrower than verifying every statement in a security report.

That admission makes the example more useful than a generic demonstration of a cited answer. It identifies the remaining work instead of treating successful retrieval as successful analysis. A security team still needs authoritative vulnerability information and review before acting.

The broader lesson applies to less specialized workflows. Imagine a product manager tracking a vendor’s announcements. Finding a page that names the product does not establish that a feature is generally available. The page might discuss a preview, a regional release, or a future commitment.

A reporting application should preserve those distinctions when transforming evidence into prose. Otherwise, adding search simply gives unsupported conclusions a more convincing presentation. A citation helps readers inspect a claim, but its presence alone does not establish support.

The example also illustrates why fixed rules should remain outside the model when they represent application requirements. A reporting window should not expand merely because broader results make a summary easier to write. A source restriction should not disappear because the agent wants another query.

Those are application design implications, rather than evidence that every direct integration implements them. Teams can enforce rules carefully through code. They can also build a thin wrapper that leaves important choices unconstrained. The API does not determine which approach they take.

This is where AgentCore search explained as a single-call convenience becomes incomplete. The call simplifies evidence acquisition. The surrounding workflow decides whether that evidence is appropriate, new, relevant, and sufficient for the intended output.

Knowledge management adds another distinction. Retrieving current public information differs from organizing an organization’s accumulated documents and decisions. A searchable knowledge base addresses a related need: making existing technical knowledge available for later use.

An application combining both sources should preserve their origins. A public announcement, an internal interpretation, and a model-generated summary carry different evidentiary weight. Merging them into a fluent paragraph should not erase those differences.

IAM access does not settle audit or answer quality

Authentication establishes who can call search; it does not establish what an answer proves or whether every relevant decision is recorded.

The AgentCore Web Search API fits familiar AWS identity controls, but audit coverage requires a separate configuration. Teams evaluating the release should distinguish service access, recorded activity, enforced source policy, and evidence quality.

AWS’s CloudTrail data events documentation states that search logging is not enabled by default. CloudTrail, AWS’s activity logging service, requires an event selector for this resource type. Recorded request parameters omit search text and filters.

That creates a meaningful distinction between an access record and an evidence record. Knowing that an identity invoked search does not reveal which question it asked or which source restrictions it supplied. An incident investigation might need both kinds of information.

Application owners therefore face an observability decision. Observability means retaining enough operational information to understand system behavior. For a search-backed application, that might include selected sources, applied policy versions, rejected findings, or links shown to users.

More logging is not automatically better. Search queries can reveal internal interests, and retained extracts can create additional data-management obligations. The appropriate record depends on the application’s purpose and the questions its operators must answer.

The important point is specificity. A team should be able to explain what its records establish. A log showing successful authorization supports a different conclusion from a record showing why an application accepted a claim.

Answer quality requires a similarly careful separation. Amazon’s announcement establishes product behavior and intended use. It does not supply an independently controlled comparison proving that the index retrieves better evidence than competing services.

Without a matched evaluation, claims about superiority would exceed the available evidence. Search relevance depends on the queries, source coverage, freshness requirements, and scoring method. An interface that is easier to integrate can still require substantial testing for a particular workload.

There is also no reason to assume that changing access paths improves the underlying index. Both routes use the same search infrastructure, according to AWS. A direct connection can simplify application architecture without improving what the search backend finds.

The skeptical reading is therefore bounded. The launch supports a claim about integration choice. It leaves application-specific evidence quality and the effectiveness of locally implemented controls to be demonstrated.

That does not diminish the release’s practical value. Removing an unnecessary component can help developers adopt a service. The value becomes clearer when teams distinguish the work AWS has removed from the work their application still owns.

For enterprise buyers, AgentCore API vs Gateway should consequently remain an operational assessment. A successful demonstration needs to show the intended controls holding under ordinary use and failure, rather than merely producing an attractive answer.

Watch adoption, policy consistency, and evidence quality next

The next useful signals will show whether simpler access produces maintainable applications with dependable evidence.

The first signal is adoption outside agent-centered interfaces. Watch for documented uses in existing applications, scheduled enrichment jobs, and monitoring pipelines. Those deployments would support AWS’s argument that search deserves an integration point independent of Gateway.

The strongest examples will explain what complexity disappeared. A credible account would identify the removed component and describe the resulting operational responsibility. A demonstration that merely replaces one call with another would establish much less.

If most published examples remain agent demonstrations, the broader application case will remain less developed. That would not invalidate direct access, but it would weaken the argument that non-agent workloads are a major reason for the release.

The second signal is how teams maintain source policies as usage spreads. Watch whether direct integrations develop reusable policy components or remain collections of local rules. The result will clarify how manageable application-owned governance becomes across teams.

Consistent policy enforcement would strengthen the case for direct integration in organizations with mature application platforms. Repeated drift would strengthen the argument for Gateway’s shared administration. Either outcome would refine the architectural choice without making either route universally preferable.

Useful evidence would include how organizations approve source changes and prevent models from altering mandatory constraints. It should also show how operators identify the policy applied to a disputed output. A configuration screenshot alone would not establish that behavior.

The third signal is workload-specific retrieval evaluation. Watch for tests that measure whether results support the requested claims, preserve usable citations, and satisfy freshness requirements. These measures speak more directly to application usefulness than answer fluency.

A meaningful evaluation should expose failures as well as successes. Missing publication dates, insufficient evidence, irrelevant extracts, and unsupported conclusions all help define where an application needs additional checks. Reporting only successful answers would conceal those boundaries.

Better evidence quality under matched conditions would strengthen the product’s case. Persistent gaps would narrow the workloads where its integration convenience outweighs additional verification work. Neither result should be inferred from the availability announcement alone.

For readers assessing the AgentCore Web Search API, start with a workflow whose evidence requirements you can state plainly. Decide which sources qualify, how freshness will be judged, and what should happen when metadata is missing. Identify who owns those rules and how an operator will inspect a questionable output. Then compare direct access with Gateway against that same workflow. Preserve source links throughout the process, and distinguish retrieved text from conclusions your application adds. The most informative outcome is a clear record of what the system found, what it accepted, and why. Which route makes those decisions easier for your team to maintain?

Get your work moving in remio

See what needs your attention and take the next step in Workspace.

remio currently supports Windows 10+ (x64) and Macs with Apple silicon.

Your AI Partner at Work
Get more done with remio

Plan. Create. Deliver.
All in one place.

bottom of page