AWS Gave the Harness Away. DigitalOcean Started Renting It. (2026)

Quick answer: The harness around an AI model sets your infrastructure bill, not the underlying weights. Running the exact same model across 89 terminal benchmark tasks cost $56.29 inside AWS Strands harness compared to $248.05 in Claude Code: a 77% cost reduction driven by automated prompt caching, output truncation, and context compaction. Over the 48-hour window of September 21 to September 22, 2026, AWS released this harness layer as an open-source Apache 2.0 library, while DigitalOcean launched Managed Agents to rent isolated microVM runtimes metered down to active CPU time. Founders can protect their gross margins today by swapping wrappers rather than models.

Running the exact same frontier model across 89 identical tasks produced a $56.29 cloud bill in one terminal and a $248.05 invoice in the other.

Nobody changed the model weights. Nobody swapped Claude Fable 5 for a smaller distilled open model. The difference came entirely from the wrapper: how the software parsed shell outputs, cached prompts, and pruned context history between turns.

If you sell software that runs AI agents, your cost of goods sold is mostly repeated context. You pay for the same system prompts, file dumps, and tool definitions on every execution cycle. A cheaper wrapper that maintains task accuracy changes your unit economics without retraining a single layer.

Over a 48-hour stretch on September 21 and 22, 2026, two cloud providers attacked that wrapper from opposite sides. The AWS Strands Agents team unbundled their internal agent loop and released it as the open-source Strands harness under Apache 2.0. The next morning, DigitalOcean launched Managed Agents, renting out hardware-isolated microVMs with a billing meter designed to pause when the agent waits for external responses.

Before examining the harness mechanics, an honest disclosure: you are reading this on a directory's blog. SaaSCity is a gamified startup directory featuring a live city map and human editorial review. If you are shipping an agent product, your execution runtime matters, but distribution decides whether you stay alive. You can claim a free listing page and a building on our map; adding the SaaSCity badge to your site earns a dofollow backlink and a slot in our Monday launch cohort. For faster launches, Quick Pass ($19.99) goes live within 24 hours. Founders looking for direct distribution can choose Premium ($39.99), which includes a written launch post with three sponsored links. Our domain sits at DR 64 at the last Ahrefs check (September 2026).

Key Takeaways

• The wrapper sets your margins: The same model cost 77% less on Terminal Bench 2.1 ($56.29 versus $248.05) by changing context management and tool truncation rules.
• AWS open-sources the loop: Released on September 21, 2026 under Apache 2.0, AWS Strands harness packages prompt caching, truncation, and compaction into a portable library running on any cloud.
• DigitalOcean meters the runtime: Announced on September 22, 2026, DigitalOcean Managed Agents runs existing agent CLIs inside Firecracker microVMs at $0.044 per vCPU-hour, pausing compute fees during model think time.
• Two distinct benchmark numbers: AWS published a 28% average token reduction across six multi-model benchmarks, while the 77% drop comes specifically from an 89-trial Fable 5 run on Terminal Bench 2.1.
• Mechanical cost controls: Strands cuts tokens by truncating tool outputs over 1,500 tokens, parking the full output in local files, and compacting conversation memory once it hits 85% capacity.
• Zero required rewrites: DigitalOcean runs unmodified OCI containers for Claude Code, Codex, and OpenCode, while Strands operates as a standalone SDK in Python and TypeScript.
• Verify before adopting: Both releases reflect vendor-published benchmarks; teams must run their own domain-specific evaluation suites before assuming production savings.

The invoice: $56.29 versus $248.05 on the exact same tasks

The cost difference between agent setups rarely shows up in sales demos. It appears on your monthly API bill after users run real multi-step tasks.

When the AWS Strands Agents team published their benchmark suite on September 21, 2026, they included an 89-trial head-to-head evaluation on Terminal Bench 2.1. Both runs used Claude Fable 5. Claude Code finished the run with an accuracy score of 61.8 and an API invoice of $248.05. The Strands harness finished the exact same benchmark with an accuracy score of 69.7, but its API invoice totaled $56.29.

That represents a 77% cost reduction on the same benchmark using the same model weights, while scoring higher on task completion.

Coverage of the launch split across two numbers. On September 21, 2026, The New Stack headlined the release as "45% cheaper than Claude Code and Codex." Meanwhile, the official Strands Agents announcement highlighted a headline claim of 28% lower token costs across six diverse benchmark suites.

Those numbers reflect three distinct measurements from the test campaign:

1. 28% is the average token savings across six general benchmarks running Claude and GPT models side by side.
2. 45% is the framing The New Stack used in its headline against Claude Code and Codex; AWS's own announcement post never used that figure.
3. 77% is the single benchmark run on Terminal Bench 2.1 with Fable 5, where aggressive tool truncation and prompt caching produced steep savings.

The table below breaks down the published Terminal Bench 2.1 run:

Harness	Underlying Model	Benchmark	Accuracy Score	Total Token Cost	Relative Cost
Claude Code	Claude Fable 5	Terminal Bench 2.1 (89 tasks)	61.8	$248.05	Baseline (100%)
AWS Strands	Claude Fable 5	Terminal Bench 2.1 (89 tasks)	69.7	$56.29	77.3% lower (-$191.76)

These economics explain why engineering teams are dissecting the wrapper. We analyzed where agent tokens vanish in our deep dive on tokenomics and quantifying tokens in agentic software engineering. When an agent loops through 50 shell commands, re-sending the unpruned stdout of every previous command on every new turn burns tens of thousands of redundant input tokens. Strands did not improve Fable 5's reasoning; it stopped feeding it financial waste.

What a harness actually does (and why default settings drain your runway)

To understand where those dollars went, you have to look at the mechanics of the agent loop.

An agent is essentially a while-loop. In each iteration, the loop builds a prompt, sends it to a model API, parses the response, executes requested tools, appends tool results to the conversation history, and decides whether to continue. The software coordinating that loop is the harness.

The harness controls five critical levers:

1. Tool schema declaration: Formatting parameter schemas and capabilities for the model.
2. Prompt caching management: Structuring static system instructions, tool definitions, and long context so providers bill cached tokens at a fraction of full input price.
3. Tool output truncation: Restricting how many lines of terminal stdout, grep matches, or file reads remain in the active context window.
4. Context compaction: Pruning or summarizing earlier turns before tokens hit the model context limit.
5. Error recovery: Catching context overflows, malformed arguments, or tool timeouts without crashing the session.

In unoptimized harnesses, default behaviors quietly destroy your margins. If an agent runs npm test and gets 4,000 lines of test output, a basic harness appends all 4,000 lines directly into the conversation history. On turn two, the model reads those 4,000 lines. On turn three, it reads them again. By turn twenty, your application pays to re-read thousands of lines of irrelevant stack traces on every single API call.

Strands attacks this with a simple, mechanical rule: any tool output exceeding roughly 1,500 tokens is truncated. The full output gets written to a local scratch file on disk. The harness informs the model that the output was truncated and provides the file path if it needs to inspect specific line ranges. That single rule removes massive token bloat from the prompt loop.

Prompt caching is enabled by default, and context compaction triggers whenever conversation memory crosses 85% of the model window. If an overflow occurs, the loop recovers rather than aborting the session. This mechanical discipline mirrors the techniques we explored in our breakdown of cutting LLM token costs by 60 to 95 percent with Headroom.

It is also worth separating the harness from the runtime. On September 21, 2026, Google saw its open-source Agent Executor climb to the top of Hacker News, an architecture we analyzed in our report on Google AX open agent runtime and Kubernetes scheduling. AX solves the runtime challenge: how to suspend, resume, and multiplex stateful agent pods across Kubernetes clusters. A harness like Strands or Claude Code operates inside that compute pod, governing the token loop and model interactions. You need both, but they address different cost centers.

AWS Strands: the unbundled harness as an Apache 2.0 library

AWS has spent years selling cloud compute. With Strands, the company took its internal agent engineering framework and pushed it into public open source.

Announced on September 21, 2026, the project was created by the AWS Strands Agents team: Arron Bailiss, Albert Zhao, Tim Moreton, Gautam Sirdeshmukh, Murat Kaan Meral, and Ariel Nabavian. Swami Sivasubramanian, Vice President of Agentic AI at AWS, published the launch announcement and credited Marc Brooker and the wider engineering team for the system design.

The core of the release is the Strands Harness SDK, licensed under Apache 2.0. A developer can initialize a complete production-grade agent loop in a single line of Python or TypeScript:

from strands_harness import create_harness

agent = create_harness(model="bedrock/global.anthropic.claude-opus-5")
agent("Research the top three vector databases, compare pricing and limits, and write it up in comparison.md")

As of September 23, 2026, the strands-agents/harness-sdk repository on GitHub records approximately 7.6k stars, 1.2k forks, and 2,752 commits. The repository includes a command-line interface where developers describe an agent workflow in natural language and use the /export command to generate production Python or TypeScript code.

A key architectural strength of Strands is that it is model-agnostic. While Amazon Bedrock serves as the natural default path inside the AWS ecosystem, the SDK supports Anthropic direct APIs, OpenAI, Google Gemini, local models via Ollama, and multi-model proxy routing through LiteLLM.

Strands is also explicitly built as a general-purpose agent rather than a dedicated coding tool. The base package ships with:

• A hardened shell execution environment
• File read and write tools with streaming window support
• Web search integrations
• Unique session identifiers that enable persistent resume across process restarts
• Subagent handoff protocols for decomposing complex goals
• Structured checklists and modular skill packages

Deployment is equally portable. You can run Strands locally during development or deploy it as a containerized service to Modal, Cloudflare Containers, Azure Container Apps, Google Cloud Run, Amazon ECS, or AWS Bedrock AgentCore. Reports from MarkTechPost and SiliconANGLE on September 21, 2026 stressed the portability angle instead: the harness runs against any model provider and on clouds beyond AWS.

However, a healthy dose of skepticism is warranted. As The Register pointed out in its September 21 analysis, AWS essentially marked its own homework. The benchmark campaign raced a general-purpose agent against specialized coding agents like Claude Code, Codex, oh-my-pi, and OpenCode. Until independent third parties replicate these evaluations across messy real-world repositories, treat the 28% and 77% figures as vendor-published targets.

Token efficiency is not a standalone victory. In AWS's own benchmark data, DeepSeek Harness was the most token-efficient harness tested, yet it consistently reported the lowest accuracy scores. If a harness truncates context so aggressively that the model cannot reason through complex dependencies, saving 80% on tokens is meaningless because the software fails to work. Strands struck a balanced compromise on Terminal Bench, but teams must verify that balance on their own tasks. Benchmarking ran distributed on EC2 with Harbor, and AWS has promised a formal research paper detailing the methodology.

DigitalOcean Managed Agents: putting the meter on the wrapper

While AWS gave the harness away as open-source code, DigitalOcean took the opposite path. On September 22, 2026, DigitalOcean (NYSE: DOCN, Broomfield, Colorado) launched the public preview of Managed Agents.

Instead of asking developers to manage container clusters, configure microVMs, and secure API keys, DigitalOcean built a managed platform that pairs an isolated runtime with a governed tool gateway.

The product combines two vertically integrated services under a unified security and billing framework:

1. Harness Runtime: A secure execution environment that provisions a hardware-isolated Firecracker microVM for every agent session. Each microVM has its own ephemeral compute and dedicated filesystem. Sessions support instant pause, resume, and checkpoint branching. If an agent goes idle, the system automatically pauses the microVM. Workflows can trigger via cron schedules or inbound webhooks. Developers can deploy their own agents as standard OCI container images and save them as reusable templates.
2. Action Gateway: A centralized tool access layer connecting agents to more than 16,000 tools across 500+ SaaS providers through a single Model Context Protocol (MCP) endpoint. Integrations include GitHub, Stripe, HubSpot, Snowflake, PagerDuty, Box, Supabase, and Exa. Crucially, the gateway provides credential brokering: authentication secrets resolve at execution time inside the gateway. The agent, the prompt context, and the microVM filesystem never touch the underlying API keys. The gateway also enforces human-in-the-loop approvals for sensitive write actions, automatic rate limiting, and exponential retry backoff.

The primary operational advantage of DigitalOcean Managed Agents is compatibility. You do not need to rewrite your agent to use proprietary SDKs. DigitalOcean runs existing harnesses unmodified: Claude Code, OpenAI Codex CLI, OpenCode, Hermes, and frameworks built with LangGraph or CrewAI. This extends the microVM pattern we examined in our analysis of AWS Lambda microVMs and stateful SaaS sandboxes.

DigitalOcean published aggressive performance benchmarks in its official launch announcement on September 22, 2026:

• Resuming a paused session takes 305 milliseconds, which DigitalOcean claims is 46% faster than competing microVM platforms. (The marketing product page describes this informally as "about 200 milliseconds.")
• MicroVM creation to first agent response is 31% faster than standard container cold starts.
• Semantic tool search in the Action Gateway matches user intent with 99.3% accuracy, a 42% improvement over conventional tool lookups.
• Up to 37% lower monthly total cost of ownership compared to leading independent sandbox providers.

Early design partners are already running production workloads on the platform. Video infrastructure company Qencode deployed a support triage agent across Slack, email, and Intercom that verifies customer issues and automatically opens Jira tickets, saving an estimated four to eight engineering hours each week. OpenHands and Amplitude (for its Wave analytics agent) also use the runtime for isolated task execution. New DigitalOcean accounts receive $5 in free credits, and sessions can be spun up directly from the Cloud Console or the doctl CLI.

The economics: active-CPU billing versus permanent virtual servers

The real innovation for bootstrapped founders and lean engineering teams is how DigitalOcean structures its pricing.

Traditional cloud hosting forces you to pay for idle capacity. If you run an agent on a standard virtual private server (VPS) or a persistent container, you pay for compute 24 hours a day, even though the agent spends 90% of its time waiting for API completions or user instructions.

DigitalOcean introduces active-CPU metering:

• Active compute: $0.044 per vCPU-hour
• Memory: $0.0095 per GB-hour
• Storage: $0.05 per GiB-month for persistent session volumes, snapshots, and checkpoints
• Network egress: $0.01 per GiB

When an agent pauses to wait for a model completion or an external web tool response, CPU billing stops immediately. When a session is fully paused, both CPU and memory billing drop to zero. You only pay the nominal $0.05 per GiB-month fee to preserve the microVM filesystem state on disk.

The platform offers five distinct sandbox tiers, detailed on the DigitalOcean Harness Runtime pricing page:

Sandbox Size	vCPU Allocation	Memory Allocation	Full Allocation Rate (Hourly)	Effective Paused Compute Rate
XSmall	1 vCPU	1 GB RAM	$0.0535 / hr	$0.00 / hr (storage only)
Small	2 vCPUs	2 GB RAM	$0.1070 / hr	$0.00 / hr (storage only)
Medium (default)	2 vCPUs	4 GB RAM	$0.1260 / hr	$0.00 / hr (storage only)
Large	4 vCPUs	8 GB RAM	$0.2520 / hr	$0.00 / hr (storage only)
XLarge	16 vCPUs	32 GB RAM	$1.0080 / hr	$0.00 / hr (storage only)

Founders need to read the documentation carefully. The pricing FAQ contains two caveats:

1. Dynamic active-CPU metering is listed as "coming soon" during the initial preview window. Until dynamic detection is fully activated, DigitalOcean bills active sessions at a flat 25% of allocated vCPUs. That is still significantly cheaper than running dedicated 100% capacity, but it is not true zero-CPU billing yet.
2. Harness Runtime requires a positive prepaid account balance. DigitalOcean explicitly warns that an autonomous agent caught in an infinite execution loop or compromised by prompt injection can drain a balance quickly if you do not set hard session timeout limits.

The cost math for a typical startup demonstrates the impact of these changes. If your product runs background coding or data analysis agents burning $2,000 per month on Anthropic or OpenAI tokens, adopting a disciplined harness like AWS Strands with a 28% average token reduction saves $560 every single month.

Pairing that token discipline with metered compute compounds the savings. A permanent 4 vCPU / 8 GB server on most clouds costs roughly $48 per month whether you use it or not. If your agents run batch jobs totaling 30 hours of actual execution per month, the 4 vCPU / 8 GB Large shape bills about $7.56 at full allocation. You stop paying for the hours your agent spent thinking. We detailed the broader cost profile of developer agents in our breakdown of Claude Code pricing and real-world costs in 2026.

Three production paths: self-host, rent, or keep it on your laptop

With AWS offering an open harness and DigitalOcean offering a metered runtime, founders face three viable architectural paths. None of them require rewriting your core agent logic.

Architecture Path	Primary Technologies	Infrastructure Model	Best Suited For	Operational Trade-Off
1. Self-Hosted Open Harness	AWS Strands, LiteLLM, ECS / Cloud Run	Self-managed containers on your own cloud	High-volume SaaS with specialized prompts and internal ops teams	Requires managing your own sandbox isolation and scaling rules
2. Managed Harness Runtime	DigitalOcean Managed Agents, Action Gateway	Metered microVMs with brokered tool credentials	Multi-tenant SaaS, background jobs, external API actions	Relies on third-party platform availability and prepaid balances
3. Local Developer Loop	Claude Code, Codex CLI, local terminal	Runs directly on your workstation or devbox	Solo founders, quick prototyping, local codebase refactoring	Jobs terminate if your laptop sleeps; unpruned tokens inflate bills

The right choice depends on where your product lives in its lifecycle:

Path 1: Self-host the open harness when you have scale and custom needs

If your startup processes tens of thousands of predictable agent tasks daily, running the open-source AWS Strands harness inside your existing Amazon ECS, Cloud Run, or Modal infrastructure makes economic sense. You gain full control over the compaction threshold, tool truncation cutoffs, and caching strategies. You can review how top AI engineering teams organize these systems in our guide to harness engineering and OpenAI's Codex architecture.

Path 2: Rent a managed runtime when agents interact with production systems

If your agents perform asynchronous tasks for customers, run overnight jobs, or touch sensitive corporate credentials like GitHub orgs, Stripe accounts, and customer databases, rent the runtime. DigitalOcean's Action Gateway isolates secrets so that prompt injections cannot extract production tokens. The hardware-level Firecracker microVM boundaries ensure customer data never bleeds across sessions.

Path 3: Keep the local loop for personal engineering tasks

If you are using agents as personal productivity tools to build your MVP, keep running Claude Code or Codex CLI on your machine. Moving a local developer workflow into a cloud microVM adds orchestration overhead without improving your shipping speed. Just remember to configure context pruning and shell output limits in your local settings to avoid paying the unoptimized token penalty.

What to test before migrating your production agents

Do not migrate your production agent workflows based on vendor benchmark graphics. AWS designed their tests to highlight Strands' strengths, and DigitalOcean designed their marketing to highlight Firecracker speeds.

Before committing engineering resources, run an empirical verification test on your own workload:

1. Collect 20 representative tasks: Assemble a private evaluation suite of 20 realistic tasks that your users actually execute, including simple single-turn lookups, multi-file code refactors, and complex multi-tool API chains.
2. Freeze the model and temperature: Run all evaluations against the exact same model endpoint (such as Claude Opus 5.5 or GPT-6 Sol) with temperature set to zero to minimize variance.
3. Compare harnesses side by side: Execute the suite through your current wrapper and through the candidate harness (such as AWS Strands or an agent inside DigitalOcean Harness Runtime).
4. Measure three strict metrics:
   • Total token consumption (separating cached input, uncached input, and output tokens).
   • End-to-end task completion rate (verified by automated tests or deterministic assertions).
   • Wall-clock latency and error recovery frequency.
5. Inspect truncation edge cases: Verify whether truncating tool outputs at 1,500 tokens harms your agent's ability to debug complex multi-layer stack traces or parse extensive JSON schemas.

If your accuracy holds steady while token usage drops by 20% or more, switching harnesses delivers an immediate margin expansion. If task accuracy slips because the agent loses essential context, adjust the truncation limits before moving forward.

Distribution is the other half of your unit economics

Optimizing token consumption and compute metering solves your margin problem, but margins mean nothing without paying customers.

Founders building in the AI agent space often spend weeks fine-tuning context loops and shaving pennies off inference costs while neglecting their customer acquisition engine. An efficient agent running in an empty market is just an inexpensive hobby.

This is why distribution channels like SaaSCity matter for early-stage software companies. SaaSCity provides immediate visibility to thousands of active tech founders, operators, and early adopters through an interactive live city map with human editorial verification.

Beyond immediate referral clicks, claiming an indexed directory profile builds the foundation for long-term search visibility. We documented how indexed directory profiles build domain authority, secure branded search real estate, and generate the third-party citations that AI answer engines rely on in our comprehensive guide to the SEO benefits of listing SaaS products in directories.

You can claim a permanent listing page and building on SaaSCity for free by adding our badge to your site, which activates a dofollow backlink and secures your spot in the next Monday launch cohort. If you want to skip the badge, Quick Pass ($19.99) goes live within 24 hours. For founders seeking maximum initial reach, Premium ($39.99) adds a full written launch post crafted by our team with three sponsored links, backed by our DR 64 domain (Ahrefs, September 2026).

The agent infrastructure war between AWS, DigitalOcean, and Google has commoditized the execution layer. The wrapper is now open source, and the runtime is metered down to the second. Your competitive advantage is no longer how you assemble a while-loop; it is what your agent does, how safely it executes, and how quickly you get it into the hands of real users.