AWS A2A Architecture Connects Independent Agents
AWS published a cross-organization agent reference architecture on November 12, connecting three agents without requiring their owners to share a framework. The AWS A2A architecture uses Agent-to-Agent, a protocol for communication between independently operated AI agents. Its central proposition is specific: organizations can coordinate work while retaining control over their implementations.
The example connects LangChain, a framework for building language-model applications, with Strands, an agent development SDK. An enterprise orchestrator delegates compliance work to an external agent, which requests enterprise context before answering. The relevant comparison is framework-specific integration: connecting organizations through their implementation details rather than a shared interface.
That distinction matters for developers evaluating external agent services. A working connection establishes a path for collaboration, but buyers still need evidence about permissions, answer quality, and operational behavior. AWS’s example makes that separation visible because its compliance findings are synthetic, rather than results from a live security audit.
What the AWS A2A architecture actually adds
AWS’s cross-organization agent architecture describes an enterprise and a software provider operating in separate AWS accounts. The enterprise runs its orchestrator and context agent on Amazon ECS, AWS’s container management service. The provider hosts its compliance agent on Amazon Bedrock AgentCore, AWS infrastructure for running agents.
AWS says the LangChain orchestrator communicates with the Strands agent without depending on its SDK. The provider can retain its internal tools, prompts, and model choices behind the external interface. Compatibility with that interface remains the condition for changing those internals.
The meaningful change is an executable integration pattern that separates an agent’s public capabilities from its implementation.
For a buyer, that distinction changes the architecture discussion. Instead of asking which framework every participant must adopt, the discussion can start with the work each service accepts. Framework selection becomes an internal decision, provided the agreed external behavior survives.
This is useful because organizational boundaries rarely align with software boundaries. A customer owns its policies and operating context, while a specialist provider owns its analysis service. Requiring either organization to absorb the other’s development stack creates another dependency to maintain.
A shared protocol offers a different place to draw that boundary. It gives teams a common communication contract while leaving implementation decisions behind the service endpoint. An endpoint is the network address through which callers reach that service.
The distinction should also shape how readers interpret the announcement. AWS has published a reference implementation, rather than announcing the invention of agent interoperability. The contribution is the combination of independently operated agents, different frameworks, and authenticated communication in both directions.
That combination makes the example more useful than a demonstration confined to a single application. Inside one codebase, developers can coordinate behavior through shared libraries, deployment conventions, and direct access to internal state. Separate organizations need a contract that survives without those conveniences.
The resulting opportunity is narrower than automatic compatibility with every agent product. It is a way to build against an agreed boundary instead of importing a partner’s implementation. That is a concrete architectural choice, with practical implications for procurement and maintenance.
It also gives evaluators a clearer question to ask. Can a supplier change its internal system while preserving the behavior customers actually depend on? A reference architecture supplies a starting point for testing that question, rather than a universal answer.
Independent teams gain another integration option
The immediate audience is software vendors selling specialized agent capabilities to enterprise customers. Their integration decisions affect both product reach and support obligations. Every customer-specific connection creates another combination of behavior, dependencies, and release schedules to manage.
A common interface shifts integration work toward maintaining a public contract rather than matching a customer’s internal framework.
That does not eliminate customization. Customers still differ in permitted data, required outputs, identity systems, and approval processes. The opportunity is to keep those differences from automatically becoming separate implementations of the same communication layer.
Consider a hypothetical enterprise assessing a compliance assistant from an outside provider. Its engineering team already has an orchestrator and wants to retain it. The provider wants to offer a capability without distributing its internal application or rewriting it around the customer’s libraries.
A protocol boundary gives both parties a basis for negotiation. The customer specifies what it needs to request and receive. The supplier specifies its supported capabilities and operating conditions. Each organization can then evaluate the contract independently of framework preference.
This creates pressure on tightly coupled integration strategies. A vendor claiming customers must adopt its entire development stack now faces a more specific architectural alternative. It must explain what additional value that dependency provides for the intended workflow.
That pressure does not make integrated platforms obsolete. A shared stack can simplify development when one team controls the whole application. Its benefits deserve comparison against the independence required when ownership spans customers, partners, or departments.
For buyers, AWS agent interoperability is therefore an evaluation category rather than a feature checkbox. The useful comparison includes change management, onboarding effort, and the ability to diagnose failures. A connection that works once says little about how it behaves after either party releases an update.
The same reasoning applies inside a large organization. Separate departments can have different frameworks, responsibilities, and release schedules even when they share corporate ownership. Architectural independence can matter whenever coordination requires agreement between teams that cannot change each other’s systems directly.
Knowledge ownership also becomes more explicit. A specialist service should receive the context needed for its assigned task, rather than unrestricted access to everything the customer knows. That requires a deliberate boundary around the information being supplied.
For teams organizing that information, a searchable knowledge base can support internal preparation. It remains separate from deciding what an external agent is authorized to retrieve.
The practical buying question is consequently broader than whether a provider supports A2A. Buyers should ask which dependencies remain after the protocol connection exists. The strongest answer identifies those dependencies clearly enough that both parties can maintain them.
Agent Cards make capabilities the shared contract
A2A uses an Agent Card, a structured document describing an agent’s identity, capabilities, service address, and authentication requirements. The protocol’s agent discovery guidance describes discovery through known addresses, curated registries, or direct configuration. Discovery choices depend on the deployment environment and its security requirements.
A capability description becomes part of the integration contract when another system uses it to decide where work belongs.
This is a consequential shift for product teams. A capability description is no longer merely explanatory copy for a human browsing documentation. It can influence the behavior of the application assigning work.
That makes clarity more valuable than breadth. A description should establish the intended task, relevant limits, and expected result. Ambiguous language leaves the caller to infer distinctions that the provider should have specified.
Imagine a hypothetical service described simply as handling compliance. That label leaves unanswered whether it retrieves evidence, identifies potential violations, recommends remediation, or approves a decision. Those functions carry different expectations, even if they share a broad subject area.
A more precise contract helps the calling application distinguish those responsibilities. It also gives reviewers something concrete to assess when an answer or routing decision goes wrong. Without that precision, teams risk debating intent after the system has already acted.
The protocol documentation also treats card access as a security decision. Sensitive descriptions require protection, and discovery documents should not contain embedded static secrets. Publishing a capability does not require publishing everything about the organization operating it.
The analytical implication is that discovery and trust need separate treatment. Finding an agent explains where a capability is advertised. It does not establish that the capability deserves access to a particular customer’s information.
That separation resembles ordinary supplier evaluation. A service can be easy to find while remaining unsuitable for a specific task. Procurement, security review, and technical validation still determine whether the organization should use it.
Agent Cards also create a maintenance obligation. If customers depend on a capability description, changes to that description deserve review alongside code changes. Teams should assess whether an update changes what callers are likely to request or expect.
The same principle applies to output expectations. A familiar endpoint and recognizable capability name do not guarantee stable meaning. An answer that becomes less specific, changes its assumptions, or omits necessary evidence can disrupt a workflow without breaking basic communication.
This is where AWS agent interoperability should be judged beyond connectivity. A useful evaluation asks whether independent implementations reach compatible interpretations of the contract. Passing messages successfully is necessary, but preserving task meaning is the more demanding requirement.
Framework independence therefore needs disciplined interface ownership. Someone must decide what the service promises, which changes preserve compatibility, and how customers discover important differences. A shared protocol makes that responsibility easier to locate.
Bidirectional calls make authorization more demanding
The published reference implementation uses separate Amazon Cognito user pools, AWS identity services that issue access tokens. Each organization issues tokens to its own workloads, and the receiving side restricts the trusted issuer, client, and scope. A scope identifies the permission associated with a token.
Client secrets remain within their originating accounts. The organizations exchange public onboarding values, while authenticated requests cross the account boundary. The compliance agent’s callback is restricted to the registered enterprise address and checked against the context agent’s card.
The repository also specifies compatible protocol behavior across different dependency versions. Its demonstration uses A2A v0.3, including compatibility mode for the context agent. This matters because framework independence still requires both implementations to agree on protocol behavior.
Independent frameworks do not remove the need for explicit trust, compatible versions, and bounded destinations.
Bidirectional communication makes those requirements especially visible. A supplier that answers a request has one access relationship with the customer. A supplier that calls back for information creates another relationship that needs its own authorization.
OAuth, the authorization standard used here, helps establish permitted access without transferring the organizations’ client secrets to each other. That does not mean the system operates without secrets. It means ownership and validation responsibilities stay defined across the boundary.
For enterprise reviewers, the important distinction is between knowing who called and deciding what that caller should receive. A valid identity is a prerequisite for access, not a complete data disclosure policy. The returned information still needs to match the task and the permission granted.
Consider a hypothetical callback asking which accounts belong to a production environment. The answer can affect how a finding is interpreted. It can also expose information that deserves tighter handling than a generic description of the service.
The receiving organization should therefore review the information returned by each capability. Restricting a caller to an approved address does not, by itself, restrict every detail that the service behind that address might disclose.
Failures deserve equally explicit treatment. If required context cannot be retrieved, the final answer should communicate the resulting limitation. Otherwise, a successful conversation can conceal an incomplete basis for its conclusion.
The repository labels the project as demonstration code requiring further security review, testing, and hardening before production use. That qualification belongs near the center of any evaluation. The example offers inspectable design decisions, rather than a production assurance.
A useful review would examine whether denied requests remain denied throughout the workflow. It would also test expired credentials, unexpected destinations, and unavailable context. Those are evaluation priorities, rather than claims that the sample has eliminated every related risk.
The AWS A2A architecture makes the trust boundary concrete enough to inspect. Its value lies partly in showing that interoperability includes identity and destination controls. Those controls remain engineering work even when communication follows a common protocol.
A2A vs MCP is a boundary decision
The relevant protocol comparison is A2A vs MCP, rather than a contest between interchangeable products. MCP, the Model Context Protocol, standardizes access to tools and resources. The A2A project’s protocol comparison describes the protocols as complementary: agents can communicate through A2A while using MCP internally.
The important choice is whether a dependency exposes a discrete tool or accepts responsibility for a broader delegated task.
That distinction helps prevent unnecessary architecture. A well-defined lookup does not automatically need an autonomous agent around it. Adding another reasoning component should follow from the work required, rather than enthusiasm for a protocol.
A straightforward operation might accept a precise input and return a predictable record. A delegated service might instead determine which evidence to gather and how to combine it. The caller’s expectations differ because the supplier controls more of the execution.
Neither design is universally preferable. A narrow interface can make behavior easier to understand and verify. A broader service can keep specialized reasoning and coordination within the organization best placed to maintain them.
The AWS example is relevant to the broader-service case because it crosses organizational ownership. A customer is requesting a capability from a separately operated system. The architecture discussion concerns how to preserve that separation while allowing useful collaboration.
The comparison also clarifies why framework labels are insufficient. LangChain and Strands are development choices inside applications. A2A and MCP concern different interaction boundaries. Treating all of them as competing alternatives obscures the decision an architect actually needs to make.
AWS’s A2A runtime documentation describes AgentCore as a proxy between clients and an A2A server. It preserves protocol payloads while adding hosting capabilities, including authentication and session isolation. That supports deployment, but does not determine whether an application’s decisions are correct.
This separates several claims that buyers should evaluate individually. A service can run on managed infrastructure, speak the expected protocol, and still return an unsuitable answer. Conversely, a useful analysis service can be difficult to integrate if its public contract is poorly maintained.
A sensible assessment follows the boundary that matters to the buyer. If the task is a data lookup, examine the lookup contract. If the task is delegated analysis, examine the evidence, assumptions, and accountability associated with that delegation.
A2A vs MCP becomes more useful when framed this way. The question is which party owns the reasoning and which interface accurately represents that responsibility. That question remains relevant even as specific frameworks and hosting products change.
For engineering leaders, this is also a way to contain scope. Standardize the external relationship where independence is required. Keep internal implementation choices proportional to the actual task.
Watch compatibility, real evidence, and operating behavior
Over the next few months, the useful signals are practical validations rather than broader claims about agent adoption. The AWS A2A architecture supplies a concrete example against which those validations can be compared. It does not establish the outcome of every future deployment.
The strongest evidence will show independent changes surviving realistic workloads without weakening access controls or answer quality.
The first signal is a documented compatibility test across implementation changes. A provider should be able to explain which changes preserve the customer-facing contract and show the associated results. This would strengthen the case for framework independence beyond an initial connection.
The test should cover meaning as well as message delivery. A request that reaches the service but produces an incompatible result has still disrupted the customer’s workflow. Published examples of stable behavior would be more useful than an unsupported compatibility label.
A failed test would also be informative. If a routine internal change forces customers to modify their integrations, the independence claim needs qualification. The relevant question is which dependency crossed the supposedly stable boundary.
The second signal is evidence from real compliance integrations. Synthetic findings make a demonstration easier to inspect, but they do not establish the reliability of actual evidence collection. A production evaluation needs to show where findings originate and how conclusions follow.
For compliance buyers, the result should distinguish observed evidence from interpretation. It should also state when missing context limits the answer. Those properties make a recommendation easier to review, challenge, and act on responsibly.
This would strengthen the architecture’s practical relevance without turning protocol support into a guarantee of compliance. The communication layer and the quality of the underlying assessment remain separate matters. Buyers need confidence in both.
The third signal is documented operating behavior under failure and change. Useful evidence would include revoked access, unavailable partners, revised capabilities, and incomplete responses. These scenarios reveal how much coordination work remains after the initial deployment succeeds.
An organization should also understand the infrastructure it must keep running. Managed hosting can reduce some responsibilities while leaving application operations, access policy, and service agreements with the participating teams. A protocol does not decide how those responsibilities are divided.
The A2A project’s foundation governance provides context for the broader standardization effort. Shared governance supports an interface that multiple organizations can implement. It does not substitute for validation of a particular supplier or workflow.
For teams considering a pilot, start with a bounded task and an explicit account of who owns each decision. Identify the context the supplier needs, the information it must never receive, and the evidence a reviewer expects back. Record what should happen when the context service is unavailable or access is withdrawn. Then assess the complete exchange, including the final answer’s limitations, rather than stopping when the agents connect. Use the AWS example to make those boundaries reviewable and to compare implementation choices against a common contract. The next purchasing decision should follow from those results: does this service preserve organizational independence while meeting the task’s actual requirements?



