An application designed for people usually assumes that a known interface will collect input, validate it and present the next available action. An agent changes that assumption. It may gather context from several systems, choose a capability dynamically, retry after failure and continue after the original interaction has ended. Modernising for that behaviour is not a faster version of an API migration. It changes where the application exposes capability, establishes authority, holds state and proves what happened.

Agents cross a different application boundary

A conventional application boundary is often shaped around channels. A browser, mobile application or partner API sends a request. The application validates it, changes a record and returns a response. The user or calling system supplies much of the sequence. Even when the implementation is complex, the interaction path is comparatively explicit.

An agent can turn one request into several model calls, context lookups, tool invocations and follow-on decisions. AWS's current Agentic AI Lens describes these systems as multi-step, stateful and able to act without explicit human instruction at every stage. That is provider guidance rather than a universal architecture standard, but the distinction is useful. The application is no longer serving only a predetermined transaction. It is participating in a bounded course of action.

This expands the effective boundary beyond the user interface and public API. Tool descriptions influence which capabilities are selected. Retrieved context influences the decision. Permission and confirmation determine whether the action can continue. Events and stored state determine whether work survives beyond the request. Telemetry determines whether an operator can reconstruct the outcome. These elements become part of the product even when they are implemented outside the original codebase.

Expose capabilities, not application internals

The quickest integration is often to place an existing API behind a tool definition. That can work for narrow read-only tasks. It becomes fragile when an API reflects screen behaviour, database structure or historical protocol details rather than a stable business capability. An agent then has to infer which sequence of low-level operations produces the intended result and how to recover when one step fails.

MCP tool definitions make the interface problem visible. A tool has a name, description and input schema, with an optional output schema. Those fields are not merely integration metadata. They tell a reasoning system what an application can do and how to ask for it. A weak contract can make an unsafe or ambiguous capability appear usable. A strong contract represents one meaningful action, validates its inputs and returns a result that another component can interpret reliably.

Design the agent-facing seam around business intent. Prefer `prepare-renewal-proposal` or `place-order-within-approved-limit` to a catalogue of generic record mutations. Keep policy, invariants and transaction control inside deterministic application code. Let the agent choose among bounded capabilities, not reconstruct the application from primitives. This makes the boundary more useful to other agents and channels without moving core business integrity into a prompt.

Events and state become part of the contract

A request-response API assumes that useful work completes inside one exchange or that the caller already understands how to poll for the result. Agentic work frequently spans minutes, approvals, external dependencies or several attempts. The system needs to distinguish a plan from a committed action, a request from an accepted task and a retry from a new instruction.

Event-driven architecture uses state changes to communicate between services without requiring every interaction to wait synchronously. AsyncAPI's guidance is deliberately general, but it clarifies the architectural option. For agents, events can announce that evidence arrived, an approval changed, a dependency recovered or a task reached a safe stopping point. Durable state can then preserve progress without asking the model to recreate the workflow from conversation history.

This is also a reliability boundary. AWS recommends adapter interfaces, defined fallbacks and idempotent side-effecting operations when agents reach legacy systems. The specific implementation will vary. The design questions do not: what is the task identifier, which state is authoritative, which transitions are permitted, what can be retried safely, how is duplicate work prevented and how can an operator cancel or resume the action?

Context and authority must travel together

An agent may need product rules from one source, customer state from another and a transactional capability from a third. Making those sources reachable does not establish that they can be combined for this user and purpose. The application boundary must carry enough identity and policy context for every resource and action to make its own decision.

OWASP describes excessive agency as the risk created when an LLM-based system has too much functionality, permission or autonomy. The guidance is security-focused, but it supports a wider product principle. Do not rely on the agent to remember a restriction that the underlying application cannot enforce. Limit available capability, scope permissions to the action and require confirmation where consequence changes.

Context needs an equivalent contract. The agent should be able to identify the source, version, freshness and permitted use of material information. An action should retain the relevant evidence and policy state, not only the generated explanation. This joins two earlier WQA arguments: fragmented context cannot be repaired by retrieval, and authority cannot be inferred from a broad authenticated session.

Observe the complete action, not only the application call

Traditional application monitoring can show that an endpoint returned successfully while missing why the agent selected it, which context informed the request and what happened after a partial failure. Infrastructure health remains necessary. It is no longer sufficient evidence for an agent-mediated outcome.

AWS recommends tracing reasoning steps, tool invocations, memory operations and hand-offs across service boundaries. Its service recommendations are vendor-specific. The architectural implication is portable: preserve one trace across the agent, application adapter, event path and system of record. Record enough structured evidence to attribute latency, cost, failure and final outcome without retaining sensitive reasoning or context indiscriminately.

Ownership must follow that trace. The application team remains responsible for its capability contract and invariants. The agent product team owns orchestration and evaluation. Platform teams own the shared identity, context and telemetry services they provide. The workflow owner decides whether the combined outcome is acceptable. If every team can see its component but nobody owns the complete action, the expanded boundary has created an operational gap.

Modernise through an agent-facing seam

There is a reasonable counterargument that many critical applications should not be redesigned around agents. Their stable interfaces may already support workflows that produce dependable outcomes, and a major re-architecture could introduce more risk than it removes. That is correct. Agentic modernisation does not require every application to become an agent runtime or every monolith to become microservices.

Create a seam around the capabilities required for the intended outcome. An adapter can translate a bounded tool contract into an existing protocol, apply rate limits and policy, add idempotency and produce consistent errors. A routing layer can move selected actions to new components while the existing application continues to serve established channels. AWS's strangler fig guidance provides one infrastructure-specific example of this incremental transition pattern.

Use production evidence to decide what happens next. Retain the adapter when it provides a stable boundary at acceptable cost. Refactor the underlying capability when protocol limitations, failure rates or change friction remain material. Replace a component when ownership or data constraints prevent dependable action. Retire only after consumers, operational responsibilities and recovery paths have moved. The target boundary and the transition route should be designed together.

Make six boundary decisions before implementation

Apply the following framework to one consequential action rather than the application estate in the abstract. Its purpose is to decide what must change at the boundary and what can remain behind it.

A credible target is not the architecture with the most agent-specific components. It is the boundary required for an approved action to proceed with explicit context, enforceable authority, recoverable state and observable consequence. That boundary can expand as evidence supports more capability. It should also be possible to narrow or disable it when the operating evidence changes.

Modernising for agents therefore changes more than the interface presented to a model. It changes the contract between intent and execution. Applications become participants in a governed action system, with clear seams for context, authority, state and evidence. Design that system deliberately and the existing estate can evolve in controlled increments. Ignore it and the agent will expose every hidden assumption at production speed.

  • Capability: What meaningful action should the application expose, and which invariants must remain deterministic inside it?
  • Context: Which information may inform the action, who owns it and how will source, freshness and permitted use remain visible?
  • Authority: Whose identity and delegated permission apply at each step, and where does consequence require confirmation?
  • State: Which task and business states are authoritative, which transitions are valid and how will retry, cancellation and recovery work?
  • Evidence: Can one trace connect intent, context, tool selection, application change and final outcome without collecting data indiscriminately?
  • Transition: Which capability should be adapted, exposed, refactored, replaced or retired first, and what evidence will govern the next move?

Sources and further reading

  1. Amazon Web ServicesAgentic AI Lens
  2. Amazon Web ServicesLegacy system integration
  3. Amazon Web ServicesObservability and monitoring for agentic systems
  4. Model Context ProtocolTools
  5. OWASP Gen AI Security ProjectLLM06:2025 Excessive Agency
  6. AsyncAPI InitiativeEvent-Driven Architectures
  7. Amazon Web ServicesStrangler fig pattern