Getting an agent up and running has always required resolving a long list of infrastructure issues before being able to test whether the agent itself performs. You connect the infrastructure, the storage, authentication, and deployment pipelines, and by the time your agent handles its first real task, you’ve spent days on the infrastructure instead of the agent logic.
We built AgentCore from the ground up to help developers focus on building agent logic rather than backend plumbing, working with frameworks and patterns they already use, including LangGraph, LlamaIndex, CrewAI, Strands Agents, and more. Today, we’re introducing new features that further streamline the agent creation experience, removing the infrastructure barriers that slow teams down at every stage of agent development, from first prototype to production deployment.
Going from an idea to an active agent in three steps
Each agent has an orchestration layer that contains the loop that calls the model, decides which tool to call, returns results, manages context windows, and handles failures. Running this loop requires infrastructure underneath: a compute to host the agent, a sandbox to run the code securely, secure connections to tools, persistent storage, and error recovery. This infrastructure constitutes the agent bundle, allowing an agent to actually execute.
Until now, building this harness was the first thing each team had to do from scratch. This meant choosing a framework, writing the orchestration code, connecting it to tools and memory, and ensuring authentication, all before the agent could process a single request. It’s necessary work, but it’s not work that tells you whether your agent is going to be useful. Most of the teams we’ve worked with spent days on this infrastructure before they could do their first real test.
The new Managed Agent Harness feature in AgentCore replaces all of that initial construction with simple configuration. You declare your agent and run it in just three API calls, without writing any orchestration code. You define what your agent does: what model it uses, what tools it can call, and what instructions it follows. All of AgentCore brings together compute, tools, memory, identity, and security to create a running agent that you can test in minutes. Trying a different model or adding a tool is a configuration change, not a code rewrite. You can test multiple variations of an agent in minutes by changing the API setting on the fly.
This speed does not come at the expense of flexibility. The AgentCore harness is powered by Strands Agents, AWS’s open source framework. When you need custom orchestration logic, specialized routing, or multi-agent coordination, you move from configuration to code-defined harness, with the same platform, microVM isolation, and deployment pipeline. AgentCore maintains session state on a durable file system, so agents can pause a running task and pick up exactly where they left off. This makes human-in-the-loop models practical without custom plumbing and without redesigning the agent later when these needs arise. You can get started in minutes, then add more features and control as your needs evolve, without any rearchitecting.
Create, deploy, operate your agents from the same terminal
Your agent is up and running and now you want to run it in production. This usually means going out of your editor, setting up a deployment pipeline, setting up environments, and putting together a process that looks nothing like the workflow you used to create the agent in the first place.
The new AgentCore CLI keeps you in a single workflow throughout the lifecycle: prototype, deploy, operate, from the same endpoint you already work in. You iterate on your agent locally and when it’s ready, you deploy it without changing tools or creating a separate pipeline. AgentCore powers deployments via Infrastructure as Code (IaC) with CDK and Terraform support (coming soon), so your agent configuration is reproducible and version controlled. What you tested locally is exactly what works in production.
Give your coding agents the right context
Throughout the agent development journey, most developers work alongside a coding assistant, such as Claude Code or Kiro. But a coding wizard is only as good as the context it has. A general-purpose MCP server might give it access to APIs and documentation, but it doesn’t encode the important opinions: what models to use, how features fit together, what the recommended path looks like for common tasks. New predefined skills in AgentCore go beyond raw API access. They give coding agents in-depth, current knowledge of AgentCore best practices, so the suggestions you receive reflect how the platform is intended to be used, not just existing endpoints. Kiro already includes it today as a built-in powerhouse, with plugins for Claude Code, Codex and Cursor coming soon. On a rapidly evolving platform, having accurate context in your coding agent means fewer wrong turns from the very first line of code.
To start
THE managed agent harness In AgentCore East available in preview Today in four AWS A.regions: Western US (Oregon), Eastern US (N. Virginia), Asia Pacific (Sydney), And Europe (Frankfurt). AgentCore CLI and persistent agent file system, are available AWS Advertising A.regions Or AgentCore is offered. Coding Agent skills will be available by the end of April. You only pay for the resources that you use, without additional bill the CLI, harness or skill (learn more In AgentCore Pricing Page). Visit AgentCore Documentation has to start.
You can use these features to stay focused on the agent logic, without worrying about infrastructure configuration. As your agent evolves, you add assessments, memory, tool connections, and policy enforcement without rearchitecting. The platform you prototype on is the same platform you use in production.
For more information on these new features and to get started with AgentCore, visit the source link.
“`
