Yuval Avidani
Author
"You write the agent, we run it." That's the sentence that, in my eyes, sums up everything AWS showed with AgentCore, and I want to break it down with you slowly — because behind this short sentence hides the most important division in the agent world this year.
Let's start from the basics, because I can't assume anything. An agent is software that receives a goal and decides on its own what steps to take to achieve it — it thinks, picks a tool, activates it, looks at the result, and repeats until it's done. Think of it like a personal assistant we give a task ("schedule me a meeting with three people this week"), and it decides on its own to open the calendar, check availability, send invites. The difference between an agent and a regular bot is exactly this "on its own" — the agent decides the order of actions, not us.
The problem: building an agent is easy, running it in production is a nightmare
Here's the cool part — writing an agent that works on our own machine takes an hour these days. But turning it into something that thousands of users trust simultaneously? That's a whole different story. Turns out the hard part isn't the AI — it's everything around it.
Think about everything we need to worry about the moment an agent goes live. We need isolation between users, so that Dana's conversation doesn't leak into Moti's. We need memory, so the agent remembers what we talked about yesterday. We need security and permissions, so the agent doesn't access things it shouldn't. We need scale, so it doesn't crash when a ton of users show up at once. And we need monitoring, so we know if it's actually doing a good job. All of this is the vast majority of the work, and it has nothing to do with the original idea of the agent.
The answer: a managed platform that takes care of all the annoying part
This is where AgentCore comes in. Amazon Bedrock AgentCore is a fully managed platform that runs AI agents at production scale for developers who want to deal only with the agent's logic and not the infrastructure underneath it. That's the definition — now let's break down every word.
"Fully managed" in plain terms: we don't maintain servers. Think about the difference between buying a car versus ordering a taxi — in both cases we get to our destination, but with a taxi someone else worries about fuel, maintenance, and parking. AgentCore is the taxi. We write where to go (the agent's code), and they handle all the mechanics.
The platform is built modularly — you can take it all together or just one piece. Here are the core components:
Let's pause for a second on two concepts that keep coming up here. Session isolation is the mechanism that gives every run of the agent its own sandbox, so that nothing from one run touches another. Think of it like separate washing machines at a laundromat — nobody mixes our laundry with the neighbor's. This is critical when a lot of people are using the same agent at the same moment.
The second concept is MCP. MCP is a unified standard that lets an agent talk to external tools without us writing a custom adapter for each one — think of it like a USB-C port: once every device had a different cable, and today there's one standard that connects to everything. AgentCore's Gateway takes our existing APIs and Lambda functions and turns them into tools the agent knows how to activate through this MCP. Meaning, if we already have an old API in the organization, we don't rewrite it — we just wrap it and give the agent access.
The 2026 breakthrough: the harness that runs the loop for us
Now comes the part that made me smile. In 2026 AWS unveiled several things in preview, and the star among them, in my view, is the managed harness.
Let's understand what an "agent loop" even is. When an agent works, it runs in a cycle: thinks about what to do, picks a tool, performs an action, gets a result, and streams a response — then again from the start until the task is done. Until now, we had to code this cycle ourselves (this is what's called orchestration code — the code that manages the order of actions). The harness is the infrastructure that runs this loop for us, so that you define an agent with just three things: a model, a system prompt, and tools — and run it immediately, without writing a single line of orchestration code.
Think of the harness like a ready-made engine versus building an engine from scratch. We used to have to assemble the pistons ourselves; now we get a ready engine and just tell it where to drive. Alongside this came AgentCore CLI (a command-line tool for fast work) and AgentCore skills for coding assistants, which bring all of this straight into our development environment.
This is why I think "you write the agent, they run it" is the right direction. Our value as developers is in the idea and the unique logic — not in rebuilding session isolation that's already been solved a thousand times. When the infrastructure becomes an off-the-shelf commodity, we're freed up to focus on what actually differentiates us.
The feature that's exciting and scary in the same breath: an agent that pays on its own
And here we get to the part that kept me up at night. AgentCore Payments, in preview and in partnership with Coinbase and Stripe, lets AI agents autonomously access and pay for APIs, MCP servers, web content, and other agents.
Read that again, slowly. Agent. Pays. Money. On its own. In my eyes this is one of the most significant — and also most unsettling — steps I've seen this year, and it's worth stopping on.
The exciting side: an agent that can pay on its own is an agent that can truly close the loop. Think about an assistant that doesn't just find us a flight, but also buys it; doesn't just locate an API that will fetch a missing piece of data, but also pays for it on the fly. This turns the agent from an advisor into an executor.
The scary side: the moment you give autonomous software access to a wallet, every bug isn't just another red log line — it's real money going out. This is exactly why the components we talked about earlier — Identity (authentication and delegated permissions against existing identity providers) and Observability (real-time monitoring) — stop being nice-to-haves and become mandatory. I want to know exactly who the agent is, what it's allowed to do, and how much it can spend, before I hand it the credit card.
So how do you actually build an agent like this
So this doesn't stay abstract, I put together the logical flow of working with the platform. Notice how little of it is infrastructure.
Bottom line, as I see it: AgentCore doesn't invent the agent — it organizes everything around the agent, and that's exactly the part that's been stopping projects from reaching production until now. I'm excited about the harness because it lowers the entry barrier to the floor, and I'm cautious about Payments because it raises the risk ceiling. Two opposite movements, in the same announcement.
It's important that I'm fair here: everything I described is mostly in preview, meaning it's early, it might change, and you need to test it in the field before trusting it in real production. And of course — this isn't investment advice or financial advice, it's a technical read of what I'm seeing. Other providers also have different approaches to the same problem, and it's not a question of who's "better" but which architecture fits what we're building.
So I'll ask you: on the day an agent can receive a goal, choose tools, run the loop on its own, and pay for whatever it needs along the way — what's the first thing you'd let it do?