Amazon ECS vs. Amazon EKS : Architecture, Cost, Skills, and Running Agentic AI Workloads
How to choose a container platform on AWS now that managed options have closed the operations gap, with a five-signal team test and guidance on where AI agent workloads fit.
The question that keeps coming back
I have spent seven years building AWS infrastructure, and I currently run workloads on both Amazon ECS and Amazon EKS. Almost every new project starts with the same question: which one should this go on?
On ECS, I run long-lived web applications and an identity service backed by a managed relational database. These need a load balancer, secrets and little else. On EKS, I run a GitOps-managed platform of microservices and AI workloads, where node autoscaling and Spot capacity do most of the cost work.
The old rule of thumb was "ECS when you are small, EKS when you scale." I no longer think that holds, for two reasons:
- AWS removed most of the operational gap. EKS Auto Mode, EKS Capabilities, ECS Managed Instances and ECS Express Mode all shipped in the last two years. A lot of what made EKS heavy and ECS limited is now optional.
- Agentic AI changed the shape of the workloads. Agents run untrusted code, hold long sessions, sit idle waiting on model calls, and sometimes need GPUs. Those requirements pull in different directions.
This guide covers what changed, five signals to score your team, three scenarios, the real cost drivers, and where agent workloads fit.
1. Why most enterprises still default to EKS
In the CNCF Annual Cloud Native Survey published in January 2026, 82% of container users reported running Kubernetes in production, up from 66% in 2023 ( CNCF ). The survey polls the cloud native community, so it leans toward Kubernetes users, but the direction is clear.
The reasons I see in practice:
- Hiring. An engineer from GKE or AKS is productive on EKS in days. ECS concepts are AWS-specific and have to be learned.
- Ecosystem. Flux, Argo CD, Kyverno, Cilium, Prometheus, Crossplane and KEDA all assume the Kubernetes API.
- Portability. Manifests and Helm charts move between EKS, on-premises clusters and other clouds. ECS task definitions do not.
- Operators. Stateful systems and GPU stacks are usually packaged as Kubernetes operators. ECS has no equivalent extension model.
- Local parity.
kindork3dgives developers a real control plane on a laptop. ECS local testing is closer to Docker Compose.
None of these is about scale. They are about people and tooling.
2. What changed: the 2026 landscape
Launch | What it does | Why it matters to this decision |
|---|---|---|
EKS Auto Mode (Dec 2024) | AWS manages nodes, autoscaling, load balancing, DNS and block storage | Removes most add-on and node upgrade work; adds a per-instance management fee |
EKS Capabilities (Nov 2025) | AWS-hosted Argo CD, ACK and kro, running outside your cluster | GitOps without operating the GitOps tool |
ECS Managed Instances (Sep 2025) | AWS provisions and patches EC2 for ECS, including GPU instances | EC2 flexibility on ECS without owning AMIs or Auto Scaling groups; adds a management fee |
ECS Express Mode (Nov 2025) | Image plus two IAM roles gives you a load-balanced, autoscaled HTTPS service | Shortest path from container to URL on AWS |
Managed MCP servers for EKS and ECS (preview, Nov 2025) | AI assistants can inspect and troubleshoot clusters through IAM-governed tools | Both platforms are now operable by agents |
What this means:
- On EKS, the "upgrade tax" is now a choice. With Auto Mode you still plan Kubernetes version upgrades and test deprecated APIs, but AWS handles nodes and core add-ons. Run it self-managed and you own the VPC CNI, CoreDNS, kube-proxy, the Load Balancer Controller, Karpenter and the rest.
- On ECS, "no GPUs, no EC2 flexibility without toil" is no longer true.
- What has not changed: ECS has no control plane fee and no version lifecycle. EKS still has both.
3. Five signals: which way does your team lean?
For each signal, pick the statement that sounds more like your team, then count how many times you picked EKS.
1. Who operates the platform? ECS if it is one or two DevOps engineers, or developers who own their own deployments. EKS if a platform team of three or more runs shared cluster infrastructure as its main job.
2. Do you need the Kubernetes ecosystem? ECS if ALB, IAM, CloudWatch and CodeDeploy cover your needs. EKS if you depend on operators, CRDs, policy engines, a service mesh or existing Helm charts.
3. How portable must workloads be? ECS if you are committed to AWS. EKS if you need the same deployment model on-premises or on another cloud.
4. How many services, and how varied? ECS if you run fewer than about 25, mostly stateless APIs, workers and scheduled jobs. EKS if you run dozens to hundreds, with stateful systems or mixed scheduling needs.
5. What do your AI workloads look like? ECS if you call hosted models such as Amazon Bedrock and run agents as ordinary services. EKS if you self-host models on GPUs and need queue-based scaling, GPU sharing or custom schedulers.
Reading your count
- 0 or 1 EKS answers: choose ECS. Start with Fargate or Express Mode. EKS would add work without a payoff.
- 2 or 3: either works. Choose ECS if delivery speed matters most. Choose EKS with Auto Mode if you already have Kubernetes skills or expect to need the ecosystem within a year.
- 4 or 5: choose EKS. The control plane fee and upgrade planning are justified. Pick Auto Mode or self-managed nodes based on how much control you need.
Signals 2 and 3 carry the most weight. If either one is a firm EKS answer, treat the result as EKS even when the count is low.
4. Three scenarios
A. Preview environments for every pull request. 18 environments, 6 small containers each.
The fair comparison is 18 sets of ECS services against one EKS cluster with 18 namespaces, which costs about $73 a month for the control plane. Nobody should run 18 clusters (that would be about $1,314 a month before any compute). Call: ECS on Fargate if the team has no Kubernetes skills, because the environments cost nothing when idle and need no cluster. If you already run EKS, namespaces are just as good.
B. 80 microservices, steady traffic, pressure to cut compute cost.
At this service count, bin-packing and Spot handling decide the bill. Karpenter consolidates nodes continuously and handles Spot interruptions well. Call: EKS with Karpenter (or Auto Mode). ECS Managed Instances narrows this gap, so benchmark it if you are already on ECS.
C. An agent that executes generated code for a few seconds.
Fargate gives each task its own microVM, which is the right isolation for untrusted code. The catch is startup: a new Fargate task normally takes 30 seconds or more to start, and billing has a one-minute minimum. For a 15-second job, that is the wrong shape. Call: a purpose-built sandbox such as Amazon Bedrock AgentCore Code Interpreter or AWS Lambda for short runs; Fargate
RunTask when jobs run for minutes and need a full container image.
5. Cost: what actually drives the bill
Compute rates are the same on both platforms. The differences are these:
- Control plane. ECS charges nothing. EKS charges $0.10 an hour per cluster, about $73 a month.
- Falling behind on versions. An EKS cluster in extended support costs $0.60 an hour, about $438 a month. ECS has no version lifecycle.
- Managed compute fees. ECS Managed Instances and EKS Auto Mode each add a per-instance management fee on top of EC2.
- Bin-packing. Karpenter consolidates nodes continuously and diversifies Spot well. ECS capacity providers and Managed Instances have narrowed the gap.
- People. This is usually the largest line. EKS has more moving parts: version upgrades, add-ons, policy and more to know.
A small application on a self-managed EKS cluster can cost more in engineering time than in AWS charges. Kubernetes standard support lasts 14 months per version, with three releases a year, so upgrade planning never stops.
6. Why this matters more in the agentic era
Until recently, most container workloads looked alike: long-running stateless services behind a load balancer. Either orchestrator handled them well, so the choice came down to team preference. Agent workloads break that symmetry in five ways.
1. The code is untrusted. An agent that writes and runs code is executing something no human reviewed. Isolation becomes a design requirement. On a standard Kubernetes node, pods share a kernel, so you need extra layers (dedicated nodes, sandboxed runtimes, strict network policy). On Fargate, every task gets its own microVM by default.
2. Sessions are long and mostly idle. An agent may hold state for hours while spending most of that time waiting on model responses. Per-task pricing for idle time gets expensive, which favors dense packing on shared nodes. That is where EKS with Karpenter, or ECS on EC2, does well.
3. Bursts are sharp. One user request can fan out into dozens of tool calls and sub-agents. Startup time now matters as much as steady-state cost. Warm capacity on EC2-backed clusters beats cold Fargate starts.
4. Identity has to be per agent. Each agent or tool server should have its own narrowly scoped IAM role. ECS task roles and EKS Pod Identity both do this. The more agents you run, the more this design work dominates.
5. There is now a third option. Amazon Bedrock AgentCore Runtime gives each agent session a dedicated microVM and manages scaling for you. For many teams the real question is no longer "ECS or EKS" but "do I need to run the agent's compute at all?"
Where each workload fits
Workload | Best fit | Why |
|---|---|---|
Short code-execution sandboxes | AgentCore Code Interpreter or Lambda | Fast start, built for untrusted code |
Long-running agent sessions with isolation | AgentCore Runtime, or ECS on Fargate | MicroVM per session or task |
MCP tool servers and agent APIs | ECS (Fargate or Express Mode) | Ordinary HTTP services; simplest to run |
Agents calling Bedrock, coordinated by SQS or Step Functions | ECS | Native AWS integration, little to operate |
Self-hosted model inference on GPUs | EKS; ECS Managed Instances for simpler cases | GPU operators, KEDA and Karpenter on EKS; managed GPU nodes on ECS |
A platform hosting many teams' agents | EKS | Namespaces, policy engines, quotas and operators |
The practical consequence: many organizations will run more than one of these. A common shape is hosted models through Bedrock, tool servers on ECS, and a GPU inference pool on EKS. Choosing per workload is better than forcing everything onto one platform.
7. What your team needs
For ECS: one or two DevOps engineers, or developers who own their services. They need solid VPC networking, a clear grasp of task roles versus execution roles, ALB target groups, and Terraform or CDK. Day-2 tooling is Container Insights, Secrets Manager, and CodeDeploy or native blue/green.
For EKS: a platform team, or Auto Mode plus at least one strong Kubernetes engineer. They need the Kubernetes API, Helm or Kustomize, Pod Identity and RBAC, Karpenter and GitOps. Day-2 tooling is Prometheus or ADOT, a policy engine, image scanning and a GitOps controller.
Verdict
- Choose ECS when you are committed to AWS, the team is small, and the workloads are APIs, workers and tool servers. Start with Fargate or Express Mode.
- Choose EKS when you need the Kubernetes ecosystem, portability, GPU scheduling, or a shared platform for many teams. Start with Auto Mode unless you have a reason to manage nodes yourself.
- For agents, decide per workload, and check whether a managed runtime removes the question.
The best orchestrator is the one your team can operate well at 2 a.m.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article