Amazon Bedrok上的4 000万开发者如何使用Postman操作 Agent模式

人工智能

Amazon Bedrok上的4 000万开发者如何使用Postman操作 Agent模式

为演示建立一个AI agent，为4000万开发者运行一个，是不同的工程问题。 Postman开始建造Agent Mode，这是跨API测试，文档，发现和执行的AI-native工作方式。 小组预计，模型质量和及时设计是最棘手的问题。 更深层的挑战来自将agent整合到一个成熟的产品中，具有多年的界面驱动假设，广阔的表面积，以及专门的概念。

在此帖子中，Postman和AWS描述了在使一个成熟的产品清晰到AI agent时出现的建筑形态。 这些模式包括控制工具扩张，揭露基于图解的读物，以及将上下文而不是能力视为主要瓶颈。

我们还解释了Agent Mode如何利用Amazon Bedrock来进行模型灵活性，地理范围跨区域推论，模型依赖的零数据保留，以及多层次的快速缓存。 这些课一起可以帮助团队将生产agents移到原型之外。

为什么邮递员会建造 Agent 模式

兹Agent Mode是Postman的门户，Postman在11年里不断发展，开发者和用户通过扩展侧边栏，检查标签，以及打开请求，学会通过接口定位信息。 重新设计对agent的认识，在产品的API、用户体验和产品知识的分布中浮现出结构假设。 agent在数据上的原因，而不是导航屏幕。 图1说明了Agent Mode如何直接与应用程序对抗。

兹Agent Mode运行于Amazon Bedrock上，它提供了对agent背后的基础模型的管理访问。 支持Postman的全球开发者社区，借助Amazon Bedrock,Postman可以在不操作自己的模型服务基础设施的同时，保持模型选择和对吞吐量，地域加工，成本控制的灵活性的情况下，扩大这种生产工作量。 图2在以下各节审查其组成部分之前，提供了生产结构的高级别观点。

人类监督是生产设计的一部分。 兹Agent 模式要求在修改应用程序状态的行动前需要用户批准。 Postman还将可用工具对准任务范围，选择目的构建上下文，并应用模型依赖的数据保留设置。 这些控制措施减少了意外行动和不必要的数据暴露，而生产测试和监测仍然是必要的。 作为负责任的AI控制，Postman使用Amazon Bedrock Guardrails来编辑个人可识别的信息，然后才到达基础的大语言模型(LLM). 企业管理员可以在 Agent Mode 的护栏设置中打开它。

处理工具扩张

在Agent Mode中，工具定义了agent在Postman内部的行为。 早期，团队倾向于高度原子化的工具：小而精确的行动，比如打开请求，更新一个字段，或者获取特定的元数据。 这种方法支持在早期迭代时的正确性和控制，但也暴露出一些问题。

许多现实世界的工作流程需要长时间的工具调用序列。 即使每一步都很快，总体经验也感觉很慢，因为每一次行动都必须回到模式中，然后才能开始下一步行动。 用户观看agent通过他们精神上被归类为单一行动的行动。

在Postman的测试中，当可见工具集超过约40个工具时，工具选择错误增加。 agent可以调用不存在的工具，通过错误的参数，尽管有有效的方案，或者选择似乎非常合理但在上下文中是错误的工具。 较大规模或较新的模型减少了这种行为

越过一定的工具集大小，曝光更多工具可以降低agent的效能。 当前架构根据需要和上下文选择工具，并隔离单个执行线程。 该模型只看到与当前任务相关的工具。 图3说明了这一动态选择过程。

一个更微妙的问题是，许多客户端API被暗中结合到接口状态。 修改请求的工具需要打开某些元素，而其他工具则打开新的标签作为副作用。 agent不得不打开一个请求选项卡来读取，模仿接口交互而非数据推理。 Postman正在积极将工具与标签脱钩，其原生的Git特性广泛使用这种方法。 例如，Agent Mode现在可以在不开放标签的情况下在背景中发送请求，尽管仍然需要用户批准。

构建器外卖：将工具目录作为上下文预算的一部分处理。 动态地将每个任务都暴露在模型中的工具范围，并将“agent能做什么”与“UI碰巧开放”脱钩。

展示基于计划的内容

对于API Catalog等产品，Postman将多个狭义视图整合为一个查询工具。 这些产品暴露出结构化的数据，如服务正常时间、测试结果以及许多服务的终点响应时间。

鉴于基础的ClickHouse表格的图案，agent可以用加入和Where条款生成复杂的查询。 这大大减少了回答分析问题所需的不同工具的数量：

采用这种方法，工程工作从每个问题建立工具转变为一次很好的模拟数据。 agent随后可以产生比团队所列举的单个工具更广阔的查询种类。

Builder takeaway：如果数据结构完善，则让agent schema-aware读取访问查询引擎，而不是扩散单功能读取工具。 你用工具计算数据模型，生成一个更好的缩放曲线。

环境才是真正的瓶颈

邮递员最初认为丢失的工具是最大的阻塞器。 实际上，缺失或不完整的环境造成的失败多于缺失的能力。

背景是 agent 对用户在Postman 中的位置的理解，哪些实体是活跃的，当上下文错误或缺失时，即使正确的工具也变得无效。 图4区分了提供给agent的两种上下文形式。

挑战是结构性的。 超过11年，开发者和用户学会通过界面寻找信息。 重新设计对agent的认识需要多次迭代，以确定对每个工作流程重要的是什么，什么是噪音。 将现有的接口数据模型序列化并不产生有用的上下文，因为这些对象是用于渲染和数据传输的，而不是推理的。 Postman因此建造了专门的上下文处理器，将每个实体提炼成agent需要知道的。

随着更多的物体获得处理器，截断成为下一个问题。 许多字段包含用户生成的开放式数据，包括请求说明，OpenAPI规格，以及请求的有效载荷。 此数据可以覆盖上下文窗口。 认真管理上下文预算在规模上至关重要，并支持小组正在探索的文件系统支持办法，其中每个处理者不需要自定义的截断和扩展逻辑。

构建器取走：不要给模型输入您的渲染数据模型。 构建目的形状的上下文处理器，将上下文窗口视为稀缺，积极管理的预算。 噪音在模型达到极限之前就挤出信号。

拼凑起来

随着Agent Mode的演化，系统显然必须综合三个不同的组件，每个组件解决一个不同的问题。

- 客户端工具存在于Postman应用程序中，并代表agent可以采取的最后行动，例如打开请求，修改设置，运行收藏，以及检查认证。 Agent 电话 Mode还使用服务器侧工具来进行网页搜索和agent-loop管理等功能，但大多数工具都在Postman应用程序上运行。

- 通用的agent指令定义了系统级行为，包括Agent Mode应如何主动，它如何沟通不确定性，以及它携带什么样的基线产品知识。

- 知识库采用检索增生法。 Postman有一个大型的产品表面，包括多个请求协议，模拟服务器，显示器，文档，API网络，工作空间治理，变量，帮助者，代码生成，请求设置，以及收藏运行。

用静态提示编码所有这一切是不可行的，而且大多数都与给定的查询无关。 对于最初的播种，团队使用Postman的学习中心来制作简明的特写文章。 在运行时间，Agent Mode根据收到的查询和可用上下文选择知识文章。 例如，当用户选择模拟服务器时，Agent Mode会自动注入相关的文章。 这可以默认地保持agent轻量级，同时在需要时提供深度。 知识库随应用而演变，因此团队可以将Agent Mode文档载运，具有新的特性。

在 Amazon 贝德洛克上运行 Agent 模式

先前描述过对同一运行时间动作的三部分决心：对基础模型(FM)的推断调用。 以邮递员的规模来看，交通急转直下，运行、缓冲和地理处理控制有助于邮递员应付交通中断，管理推论费用，并满足具体工作量的处理要求。 兹Amazon 贝德洛克提供了四种能力这里最重要的。

Claude家族的模型灵活性

Agent 电话模式与一个模式无关。 通过Amazon Bedrock模型推论API,Postman可以访问支持的Anthropic Claude模型，并将每个工作量通向适当的模型。 一个更快的模型可以服务于高容量，耐久性敏感的相互作用，而更大的模型可以处理质量比成本更重要的复杂推理。 在支持的Claude模型之间移动主要是配置变化而不是新的集成。 这种灵活性直接支持前面描述的工具-扩张和背景挑战。 在Postman的测试中，更新和更大的模型减少了工具幻觉，Postman可以在不重建整合的情况下采用支持的模型。 见AWS区在Amazon Bedrock中支持的模型。

高吞吐量的跨区域推论

开发商流量飞涨，在一个AWS区提供高峰需求可能代价高昂。 Agent 电话 Mode使用Amazon Bedrock跨区域推论在由推论剖面定义的目的地区域间自动提出路由请求。 在运行时，应用程序会通过选定的推论配置ID或Amazon资源名称(ARN)作为Converse或InvokeModel的模型Id. 简介、适用的AWS身份和访问管理(IAM)和服务控制政策以及配额必须允许贝德洛克可能选择的每一个目的地区域。

- 地理推论剖面图路线请求只针对在界定的地理范围内得到支持的区域，例如美国或欧洲联盟。 这个选项结合了增加的吞吐量和配置的地理加工边界。

- 全球推论简介可以将请求传送到世界各地受支持的目的地区域，以便在交通中断期间提供额外的吞吐量。 只有在工作量不需要地理上受限制的加工界限时，才适用。

邮递员可以选择每个工作量的推论概况：一个全球概况，以尽量增加现有吞吐量，或者一个地域概况，而处理必须保持在该概况确定的地理范围内。 这种选择在每一个贝德罗克推断请求所用的模型Id中是明确的。

数据储存和企业控制

对于客户企业，允许的螺旋管

本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。

Artificial Intelligence

How Postman runs Agent Mode for 40 million developers on Amazon Bedrock

Building an AI agent for a demo and operating one for 40 million developers are different engineering problems. Postman set out to build Agent Mode, an AI-native way to work across API testing, documentation, discovery, and implementation. The team expected model quality and prompt design to be the hardest problems. The deeper challenges came from integrating an agent into a mature product with years of interface-driven assumptions, a wide surface area, and specialized concepts.

In this post, Postman and AWS describe the architectural patterns that emerged while making a mature product legible to an AI agent. These patterns include controlling tool sprawl, exposing schema-based reads, and treating context rather than capability as the primary bottleneck.

We also explain how Agent Mode uses Amazon Bedrock for model flexibility, geographically scoped cross-Region inference, model-dependent zero data retention, and multi-tier prompt caching. Together, these lessons can help teams move production agents beyond prototypes.

Why Postman built Agent Mode

Agent Mode is Postman’s portal for working with the product in an AI-native way across testing, documentation, discovery, and implementation. Postman has evolved over 11 years, and developers and users learned to locate information through the interface by expanding sidebars, checking tabs, and opening requests. Re-engineering that awareness for an agent surfaced structural assumptions in the product’s APIs, user experience, and distribution of product knowledge. An agent reasons over data rather than navigating a screen. Figure 1 illustrates how Agent Mode works directly against the application.

Agent Mode runs on Amazon Bedrock, which provides managed access to foundation models behind the agent. Supporting Postman’s global developer community creates variable, latency-sensitive demand with sharp traffic bursts. With Amazon Bedrock, Postman can scale this production workload without operating its own model-serving infrastructure while retaining flexibility in model selection and control over throughput, geographic processing, and cost. Figure 2 provides a high-level view of the production architecture before the following sections examine its components.

Human oversight is part of the production design. Agent Mode requires user approval before actions that modify application state. Postman also scopes available tools to the task, selects purpose-built context, and applies model-dependent data-retention settings. These controls reduce unintended actions and unnecessary data exposure, while production testing and monitoring remain necessary. As a responsible AI control, Postman uses Amazon Bedrock Guardrails to redact personally identifiable information before it reaches the underlying large language model (LLM). Enterprise admins can turn this on in Agent Mode’s guardrail settings.

Handling tool sprawl

In Agent Mode, tools define how the agent acts inside Postman. Early on, the team leaned toward highly atomic tools: small, precise actions such as opening a request, updating one field, or fetching a specific piece of metadata. That approach supported correctness and control in early iterations, but it also revealed several problems.

Many real-world workflows require long sequences of tool calls. Even when each step was fast, the overall experience felt slow, because every action had to return to the model before the next one could begin. Users watched the agent step through actions they had mentally grouped as a single operation.

In Postman’s testing, tool-selection errors increased once the visible toolset exceeded approximately 40 tools. The agent could call nonexistent tools, pass incorrect arguments despite valid schemas, or select tools that seemed semantically reasonable but were wrong in context. Larger or newer models reduced this behavior but didn’t remove it.

Past a certain toolset size, exposing more tools can reduce agent effectiveness. The current architecture selects tools based on need and context and isolates individual execution threads. The model sees only the tools relevant to the current task. Figure 3 illustrates this dynamic selection process.

A subtler problem was that many client APIs were implicitly coupled to interface state. Tools that modified requests needed certain elements to be open, while other tools opened new tabs as side effects. The agent had to open a request tab to read it, mimicking interface interactions instead of reasoning about data. Postman is actively decoupling tools from tabs, and its Native Git feature makes extensive use of this approach. For example, Agent Mode can now send requests in the background without an open tab, although user approval is still required.

Builder takeaway: Treat your tool catalog as part of the context budget. Dynamically scope the tools exposed to the model per task, and decouple “what the agent can do” from “what the UI happens to have open.”

Exposing schema-based reads

For products such as the API Catalog, Postman consolidated multiple narrow views into a single query tool. These products expose structured data such as service uptime, test results, and endpoint response times across many services.

Given the schemas of the underlying ClickHouse tables, the agent can generate complex queries with joins and WHERE clauses. This substantially reduces the number of distinct tools needed to answer an analysis question:

With this approach, the engineering job shifts from building a tool per question to modeling the data well once. The agent can then generate a far wider variety of queries than the team could ever have enumerated as individual tools.

Builder takeaway: Where you have well-structured data, give the agent schema-aware read access to a query engine instead of a proliferation of single-purpose read tools. You trade tool count for data modeling, which produces a better scaling curve.

Context was the real bottleneck

Postman initially assumed missing tools would be the biggest blocker. In practice, missing or incomplete context caused more failures than missing capabilities.

Context is the agent’s understanding of where the user is in Postman, which entities are active, and what state has already been established. When that context was wrong or absent, even correct tools became ineffective. Figure 4 distinguishes the two forms of context supplied to the agent.

The challenge was structural. Over 11 years, developers and users learned to find information through the interface. Re-engineering that awareness for an agent required multiple iterations to determine what mattered for each workflow and what was noise. Serializing the existing interface data model did not produce useful context because those objects were shaped for rendering and data transfer, not reasoning. Postman therefore built dedicated context handlers that distilled each entity into what the agent needed to know.

As more objects gained handlers, truncation became the next problem. Many fields contain open-ended user-generated data, including request descriptions, OpenAPI specifications, and request payloads. This data can crowd the context window. Managing the context budget carefully is essential at scale and supports the filesystem-backed approach the team is exploring, where each handler does not need custom truncation and expansion logic.

Builder takeaway: Don’t feed the model your rendering data model. Build purpose-shaped context handlers and treat the context window as a scarce, actively managed budget. Noise crowds out signal long before the model reaches its limit.

Putting it all together

As Agent Mode evolved, it became clear the system had to aggregate three distinct components, each solving a different problem.

- Client-side tools live in the Postman application and represent the final actions the agent can take, such as opening requests, modifying settings, running collections, and inspecting authentication. Agent Mode also uses server-side tools for functions such as web search and agent-loop management, but most tools operate on the Postman application.

- Generic agent instructions define system-level behavior, including how proactive Agent Mode should be, how it communicates uncertainty, and what baseline product knowledge it carries.

- A knowledge base uses a Retrieval Augmented Generation (RAG) approach. Postman has a large product surface that includes multiple request protocols, mock servers, monitors, documentation, the API Network, workspace governance, variables, helpers, code generation, request settings, and collection runs.

Encoding all of this in static prompts was not feasible, and most of it is irrelevant to a given query. For initial seeding, the team used Postman’s Learning Center to generate concise feature-specific articles. At runtime, Agent Mode selects knowledge articles based on the incoming query and available context. For example, when a user selects a mock server, Agent Mode injects the related article automatically. This keeps the agent lightweight by default while providing depth when needed. The knowledge base evolves with the application, so teams can ship Agent Mode documentation with new features.

Running Agent Mode on Amazon Bedrock

The three components previously described resolve to the same runtime action: an inference call to a foundation model (FM). At Postman’s scale, traffic is bursty and developer-driven. Routing, caching, and geographic processing controls help Postman accommodate traffic bursts, manage inference cost, and address workload-specific processing requirements. Amazon Bedrock provides four capabilities that matter most here.

Model flexibility across the Claude family

Agent Mode isn’t tied to one model. Through Amazon Bedrock model inference APIs, Postman can access supported Anthropic Claude models and route each workload to an appropriate model. A faster model can serve high-volume, latency-sensitive interactions, while a larger model can handle complex reasoning where quality matters more than cost. Moving between supported Claude models is primarily a configuration change rather than a new integration. This flexibility directly supports the tool-sprawl and context challenges described earlier. In Postman’s testing, newer and larger models reduced tool hallucinations, and Postman can adopt supported models without rebuilding the integration. See supported models by AWS Region in Amazon Bedrock.

Cross-Region inference for high throughput

Developer traffic is spiky, and provisioning for peak demand in one AWS Region can be costly. Agent Mode uses Amazon Bedrock cross-Region inference to automatically route requests among the destination Regions defined by an inference profile. At runtime, the application passes the selected inference profile ID or Amazon Resource Name (ARN) as the modelId in Converse or InvokeModel. The profile, applicable AWS Identity and Access Management (IAM) and service control policies, and quotas must permit every destination Region that Bedrock might select.

- Geographic inference profiles route requests only among supported Regions within a defined geography, such as the United States or European Union. This option combines increased throughput with a configured geographic processing boundary.

- Global inference profiles can route requests among supported destination Regions worldwide to provide additional throughput during traffic bursts. They are appropriate only when the workload does not require a geographically constrained processing boundary.

Postman can select the inference profile per workload: a global profile for maximum available throughput or a geographic profile when processing must remain within the profile’s defined geography. This choice is explicit in the modelId used for each Bedrock inference request.

Data residency and enterprise controls

For enterprise customers, permitted proces

Auto-fetched and translated by AI Atlas. All rights belong to the original author.