top of page

AWS Updates AgentCore Runtime for Faster, Larger Sessions

35 minutes ago
11 min read
Illustrative photograph. Photo: panumas nikhomkhai / Pexels.

AWS announced its AgentCore runtime update on November 12, expanding isolated agent sessions to 8 virtual CPUs and 32 GB of memory. The release also changes startup behavior, memory consumption, and storage access. Its central promise addresses a practical deployment problem: agents need room to work without giving every session an expensive, permanently running environment.

The update preserves hardware isolation while reducing the resource overhead associated with starting and maintaining sessions, according to AWS. However, isolated compute and authorized behavior remain separate responsibilities. An agent can stay inside its assigned environment and still misuse an overly broad permission.

That distinction puts pressure on teams operating custom agent infrastructure and buyers evaluating managed alternatives, including Microsoft’s Azure SRE Agent. The immediate question concerns how much infrastructure work AWS can absorb. The longer question concerns whether session identity, stored files, and application permissions remain aligned as agents take on longer assignments.

The AgentCore Runtime Update Expands the Session

AWS is increasing what an isolated session can handle while changing how that session starts and consumes resources.

A runtime is the environment that executes an application’s code. In this release, AWS expands that environment without abandoning separate execution boundaries. Each serverless session uses a Firecracker microVM, a lightweight virtual machine that provides hardware isolation.

The runtime announcement describes support for container images up to 10 GB. A container image packages application code and its dependencies. Larger packages give teams more room for the libraries and tools their agents require.

These changes matter most when an agent’s assignment extends beyond generating a response. Consider an engineering assistant that examines a repository, runs a build, investigates failures, and prepares a proposed change. Its execution environment must accommodate the tools and temporary files involved throughout that assignment.

That example illustrates the significance of larger sessions without establishing a performance result. More available resources create capacity for heavier work. They do not establish how quickly a particular repository builds or whether an agent selects the right repair.

The distinction matters for buyers comparing specifications. A memory ceiling describes an available configuration. A startup measurement describes one part of a session’s lifecycle. Neither number measures the quality of the final work product.

The release therefore changes a deployment constraint rather than resolving the entire agent problem. Teams gain more room inside the isolated environment. They still need to determine which tools belong there, which dependencies they trust, and which operations require oversight.

For a team maintaining its own execution service, that changes the comparison with managed infrastructure. The relevant alternative includes the engineering effort required to provision environments, update them, observe failures, and clean up after interrupted work.

An internal platform can justify that effort when it serves specialized requirements. The AWS release raises the standard for that justification. Teams now need to explain which requirements a managed session cannot satisfy.

That pressure should produce a more concrete purchasing conversation. Instead of comparing broad claims about agent support, buyers can examine the workloads that fail under existing limits. They can then ask whether the expanded environment removes those limits without introducing unacceptable operational constraints.

The announcement establishes availability across AWS Regions in North America, South America, Europe, and Asia Pacific. Organizations should verify their particular deployment location before treating that geographic coverage as a complete match for their requirements.

Faster Starts Put Custom Infrastructure Under Pressure

Startup speed matters when users experience environment preparation as part of the agent’s response time.

AWS’s runtime capabilities documentation gives the headline improvement a narrower measurement. It reports startup at 1.9 seconds at P75, compared with 29.7 seconds previously, using a 2 GB image.

P75 means the 75th percentile, the point at or below which three quarters of measured observations fall. That qualification matters. A percentile measurement does not promise that every session starts within the reported interval.

The company attributes faster starts to restoring a snapshot, a saved copy of an initialized agent environment. That approach changes where preparation happens. Work completed before the snapshot can be reused when sessions begin.

The commercial implication is straightforward. If environment preparation becomes less visible to users, teams have less reason to maintain spare environments solely to avoid startup delays. That weakens an argument for infrastructure reserved ahead of demand.

However, runtime startup and useful response time remain different measurements. An agent might start promptly and then wait for a model, retrieve documents, or contact another service. The user experiences the combined delay.

A useful evaluation therefore follows the complete assignment. It records when the session becomes available, when the agent begins meaningful work, and when the user receives a useful result. That separates infrastructure improvements from delays elsewhere.

This distinction protects both buyers and vendors from misleading comparisons. A runtime improvement deserves recognition when it removes a measurable bottleneck. It should not receive credit for application behavior that the measurement never examined.

The teams under immediate pressure are those whose custom systems mainly compensate for slow environment preparation. They must compare their operating burden against the managed alternative using the same application and workload.

Teams with specialized dependencies face a different question. They need evidence that faster environment startup survives realistic initialization, network access, and tool behavior. A smaller demonstration cannot settle that question for them.

Snapshot restoration also introduces a migration concern. AWS warns that credentials, random seeds, timestamps, and connections created during initialization require careful handling because restored sessions inherit snapshot state. Deployments also spend time preparing that snapshot.

The implication is that faster session starts involve an application lifecycle decision. Developers must distinguish reusable initialization from values that belong to an individual session. Treating the migration as a configuration change alone overlooks that distinction.

For enterprise buyers, this becomes an ownership question. Someone must review the agent’s initialization behavior, approve the migration, and interpret any failures. Managed execution reduces infrastructure work, while application compatibility still needs an accountable owner.

That is the practical meaning of AgentCore runtime explained through this release: AWS is moving more preparation into the platform. The value depends on whether the application uses that preparation safely and whether users notice the resulting improvement.

Memory Billing Follows the Work More Closely

The economic change concerns how resources behave during an assignment, especially when the agent pauses between useful actions.

AWS says the runtime reclaims memory within minutes after an agent releases it, and idle agents scale to zero. For paused, multi-turn workloads, it claims up to 68% lower memory consumption per session.

The announcement also describes a committed memory baseline for steady workloads. That baseline establishes a billed minimum, with room to burst to four times the baseline. These are different consumption patterns, and buyers should evaluate them separately.

The distinction is especially relevant to interactive work. A user might ask an agent to investigate a problem, review its findings, and provide clarification later. The conversation remains useful across those pauses, even though resource demand changes.

A continuously busy assignment creates a different economic profile. If an agent keeps processing files or executing tools, it has fewer opportunities to release resources. The advertised reduction therefore should not become a universal savings assumption.

The AgentCore runtime update changes the questions finance and engineering teams need to ask together. They need to understand when memory becomes available for reclamation, how the application releases it, and how often sessions actually pause.

That requires observing behavior rather than relying on an agent label. A conversational interface can conceal intensive background work. A seemingly complex assistant might spend much of its time waiting for a person to respond.

The same caution applies when interpreting scale to zero. Buyers should identify which resource has stopped consuming capacity and which surrounding services continue operating. Storage, model calls, and external tools belong in the broader application assessment.

The business outcome also depends on successful completion. A cheaper attempt creates limited value if failures force users to restart the assignment. Repeated work can erase an apparent efficiency gain while adding frustration.

That makes completed, acceptable work a useful unit for evaluation. Teams can compare the resources consumed by assignments that meet their quality requirements. They can then investigate whether savings come from better utilization or from incomplete work.

An illustrative research assistant shows why this matters. It might gather source material, wait for editorial feedback, and resume with a revised request. Resource reclamation during that pause has value only if the resumed workflow behaves correctly.

The example is an analytical scenario, not a reported customer result. Its purpose is to show why infrastructure economics and application continuity need to be assessed together.

A committed baseline presents another judgment. Predictable demand can make a minimum allocation reasonable, while irregular demand calls for closer scrutiny. Buyers should model their observed workload rather than assume every agent benefits from the same arrangement.

This is where the release puts pressure on platform teams maintaining large pools of reserved capacity. They need to demonstrate the operational benefit that justifies those resources. Familiar infrastructure alone is a weak explanation when a managed alternative offers a more flexible consumption model.

Storage Access Makes the Trust Boundary More Complicated

A separate execution environment does not automatically give an agent the correct scope of access to stored information.

AWS says agents can dynamically mount and save work through a filesystem, including Amazon S3 with FUSE support. FUSE allows a storage system to appear through a filesystem interface that applications can use.

That makes storage more accessible inside an agent’s working environment. However, the announcement places an additional capability in the future. It says per-session storage-folder scoping through session-labeled credentials is planned by re:Invent.

As of November 17, that wording describes a commitment. It should not be rewritten as a universally enforced feature already protecting every session.

The distinction matters because compute placement and data authorization answer different questions. Compute isolation addresses where code executes. Authorization determines which information that code can read or change.

Imagine an assistant preparing a report for a customer. Giving it a separate environment helps contain its execution. If its credentials also allow access to unrelated customer documents, the environment alone does not correct that permission.

That example does not allege a flaw in the service. It illustrates why the storage claim needs a precise reading. Access controls must align with the intended assignment, regardless of how convenient the filesystem interface becomes.

AWS’s filesystem configurations documentation provides the implementation context for storage integration. Buyers should examine that configuration alongside the identity and permissions used by their application.

The implication extends beyond confidential documents. Agents also create intermediate files, partial results, and logs. An organization needs to decide which outputs should persist and who can retrieve them after the assignment ends.

Persistence and execution isolation should therefore be evaluated together. Deleting an execution environment does not necessarily delete work saved elsewhere. Conversely, retaining files does not establish that another session should receive access to them.

For knowledge applications, this becomes a familiar information-management problem. A searchable knowledge base helps make technical material retrievable. An agent that acts on retrieved material introduces additional questions about modification rights and downstream consequences.

The relevant decision concerns authority at each step. Permission to read a design document does not inherently establish permission to edit a repository, send a message, or publish a generated report.

That is why planned folder scoping deserves attention without being treated as a complete solution. Narrower storage credentials can strengthen the relationship between a session and its workspace. Application behavior still determines which actions the agent attempts within that authorized scope.

The useful interpretation of AgentCore runtime security is therefore specific. The platform supplies an execution boundary and supporting controls. Organizations must still connect those controls to users, assignments, and stored work.

Isolation Leaves Application Owners With Important Decisions

Hardware isolation limits the execution environment; application permissions determine the authority available inside it.

AWS’s session security guidance explicitly assigns session-to-user mapping to the application backend. It also assigns customers responsibility for permissions, dependencies, executed commands, and input validation.

The documentation adds a notable storage qualification. Filesystem permission information can be stored without being enforced inside the session, where the agent operates as the only user. Familiar permission metadata therefore should not become an assumed internal boundary.

These details sharpen the release’s central tension. A managed environment can remove substantial operational work while leaving consequential application decisions with the customer. Buyers need to understand that division before assigning the platform responsibility for outcomes.

Prompt injection, malicious content that tries to redirect an agent’s behavior, illustrates the distinction. A hostile document can influence an agent without escaping its virtual machine. The resulting action might remain entirely inside the permissions already granted.

The organization therefore needs to consider what happens when an agent follows the wrong instruction. A narrowly scoped capability limits the consequences. Broad authority makes the same mistake more consequential.

This is also where competition becomes more informative than a feature checklist. Microsoft describes Azure SRE Agent, its operations assistant, as separating reasoning, tool execution, identity handling, and network controls in its execution isolation architecture.

The products serve different purposes, so that comparison does not establish an overall winner. It does show why buyers should examine the placement of authority. The location of credentials and enforcement controls matters alongside the execution environment.

A runtime comparison should ask what code can do after it starts. That includes the information it can retrieve, the services it can contact, and the changes it can make without further review.

An application can reserve approval for consequential operations while allowing lower-risk preparation to proceed. For example, an engineering assistant can investigate and propose a change before receiving authority to merge or release it.

That example describes an architectural choice rather than a default product guarantee. Its importance lies in separating useful autonomy from unrestricted authority. The runtime provides a place to execute the choice; it does not make the choice for the organization.

AWS includes customer accounts of agents performing engineering work in the announcement. Okta describes code inspection, test execution, and proposed repository changes alongside identity-governed controls. Those statements provide deployment context, while remaining customer testimony selected by the vendor.

Independent evaluation still needs to connect infrastructure behavior with application outcomes. Useful evidence includes failed access attempts being denied, incorrect session routing being rejected, and consequential actions following the intended approval rules.

Those outcomes are more revealing than a general assertion that an agent runs securely. They describe observable behavior against a defined requirement.

For enterprise buyers, the responsibility question is immediate. Security teams need to define acceptable authority, application teams need to implement it, and platform teams need to demonstrate enforcement. The release changes their infrastructure options without removing those roles.

Three Signals Will Show How the Upgrade Holds Up

The next stage should be judged through delivered controls, realistic measurements, and completed assignments.

The first signal is delivery of the announced per-session storage-folder scoping. AWS has attached that commitment to re:Invent. Buyers should watch for documentation explaining how credentials, folders, and session identity connect.

Delivery would strengthen the argument that the platform can align execution and persistent workspace boundaries. An unclear rollout or narrow applicability would limit how broadly organizations can rely on that claim.

The important evidence will describe enforcement behavior. Buyers need to understand what happens when a session requests a different folder, when credentials change, and when an assignment ends. Those details determine whether the feature matches an application’s requirements.

The second signal is workload-specific evidence for startup and memory improvements. AWS has published measurements, but buyers still need results from applications resembling their own. A benchmark becomes more useful when its conditions are explicit.

That evidence should distinguish environment startup from the time required to finish useful work. It should also show behavior during pauses, resumed interactions, and sustained demand. Those conditions reveal which applications benefit most.

Consistent improvements across representative workloads would strengthen the case for migration. Results concentrated in narrow conditions would support a more selective decision. Either outcome would be more useful than treating the largest advertised improvement as a universal expectation.

The third signal is whether organizations complete more acceptable work with less operational effort. That combines application reliability, resource consumption, and the maintenance burden carried by the team.

Faster startup can improve the experience without reducing the work required to keep an application dependable. Lower memory consumption can improve utilization without fixing permissions. Buyers need evidence that the combined system advances their actual objectives.

For teams evaluating the AgentCore runtime update, the next step is a representative assignment with explicit success criteria. Choose work that includes realistic dependencies, a pause or interruption, persisted output, and a meaningful access boundary. Compare completed results and operational effort alongside startup and resource measurements. Review initialization state before migration, then test whether the agent can reach only the information and actions its assignment requires. Keep the planned storage-scoping feature separate from controls available today. Use those findings to decide whether the managed runtime removes a real burden from your team. Ask which constraint remains after execution becomes faster: infrastructure capacity, application reliability, or the authority granted to the agent.

Give every agent the context to do better work

Connect your agents to the knowledge, decisions, and history already organized in remio.

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