How to choose AI agent platforms to run agents in production

At a workshop last week, someone asked me a simple question: “What’s the difference between Hermes and Trinity?” It’s a fair question - on the surface they rhyme: both open source, both self-hosted, both about running AI agents on infrastructure you own. But they aren’t the same kind of thing. Hermes is a personal agent - one autonomous assistant you install on your own server that learns your work and grows with you. Trinity is the platform you run agents on: the runtime that keeps many of them scheduled, isolated, recoverable, and audited in production.

That difference - an assistant versus the machinery a team runs agents on - is the one the feature checklist hides. The comparison people actually need isn’t feature-by-feature; it’s which axis to weigh, and most of the market keeps you looking at the wrong one.

The naming doesn’t help. Half the names are hype, half are genuinely good, and from the outside it’s hard to tell which will still be standing in three years. I got tired of untangling it one message at a time, so I sat down and wrote the whole thing out. This is that guide.

Here’s where I start, because it’s the part most write-ups skip.

Most write-ups I read about AI agent platforms to run agents in production are feature bake-offs. Column after column of checkmarks: does it schedule, does it recover, does it log, does it scale. Those columns matter - I’m not pretending they don’t. But I’ve now sat with a lot of teams as they crossed the line from demo to deployment, and I’ve come to believe the checkmarks answer a smaller question than the one that actually decides how it ends.

Here’s the bigger question, and it’s the one I’d want someone to ask me before I picked anything. An agent that runs continuously does not stay the same. It accumulates memory, tunes its own prompts, learns which tools work and which waste a call, and builds a history of what it did and why. Give it months and that accumulated context becomes the most valuable thing you own - more valuable than the model weights, which anyone can rent by the hour. So the question a production platform quietly settles is not “can it run my agent?” Almost all of them can. It is: who owns what the agent becomes?

Keep that lens up and the whole market reorganizes itself in front of you.

I don’t think the urgency here is hypothetical. Gartner projects that by 2028, 33% of enterprise software applications will include agentic AI, up from less than 1% in 2024 (Gartner, June 2025). That’s a steep curve. Practically, it means the platform decisions being made this year will still be running - and still compounding state - when agentic software is a third of the stack. You’re not choosing for this quarter. You’re choosing for the thing that will be load-bearing in three years.

And the counterweight is sobering. MIT’s Project NANDA, in its 2025 “State of AI in Business” report, found that roughly 95% of enterprise generative-AI pilots deliver no measurable return, with the gap concentrated not in model quality but in integration and operational deployment (MIT NANDA, 2025). Read that carefully: the models work. The production layer is where the value leaks out. I’ve built enough software to find that unsurprising, and choosing where and how agents run is exactly the decision that report is pointing at.

I don’t believe there’s an “objectively best” platform, and any list that claims one is selling you something. What’s actually useful is a stated methodology - a small set of axes that mirror what a governance or security review will eventually ask you - and an honest read of which tool leads on which axis.

Four axes carry most of the weight, in my experience:

• Ownership of compounding state. As the agent learns, does that memory, history, and improvement live on infrastructure you control, or on a vendor’s? This is the axis most comparisons skip, and it’s the one I’d start from.

• Runtime versus framework. A lot of popular tools are build-time authoring kits, not the thing that keeps an agent alive at 3 a.m. Both are needed. Conflating them is the classic planning error, and it’s expensive to discover late.

• Governed operation. Can you prove after the fact who ran what, with what inputs - and can a human halt or roll the agent back? For anything touching real systems, I don’t treat this as optional.

• Exit cost. If the vendor changes terms, is your accumulated state portable, or is it hostage?

Ranking against a declared methodology is a selection, not a verdict. With that framing, here is how a representative slice of the field sorts out - each entry reads as what it primarily is, where agent state lives, and its ownership posture:

• Trinity by Ability AI - a self-hosted, open-source production runtime; agent state lives on your infrastructure; you own it, with git-native state and no phone-home.

• OpenHands - an open-source coding-agent runtime; agent state is self-hosted; yours, with RBAC/SAML gated to the enterprise tier.

• Letta (ex-MemGPT) - a memory-centric agent framework; agent state can be self-hosted or managed; ownership depends on the path chosen.

• Agno - a lightweight open-source multi-agent framework; agent state is self-hosted; yours, with a lighter governance layer.

• Hermes Agent - Nous Research’s MIT-licensed, self-hosted personal agent - not a platform but a single autonomous assistant; agent state is self-hosted; yours, aimed at the single-user assistant rather than governed multi-user production.

• Dust - MIT-licensed with a self-host path (dsbx CLI) but sold as managed SaaS; on that tier agent state lives in the vendor cloud; vendor-operated, with mature SCIM/audit streaming and SOC 2 / HIPAA-enabling certs.

• Bedrock AgentCore / Gemini Enterprise Agent Platform (formerly Vertex AI) - cloud-hosted agent platforms; agent state lives in the vendor cloud; vendor-coupled.

I’ll put Trinity by Ability AI first, and since it’s mine I owe you precision about why - it leads on one axis, not on all of them. I’d rather tell you which one than wave at a grid.

Trinity is an open-source agent runtime, released under Apache 2.0 and free to self-host, including commercially. The design thesis is sovereignty, and I mean that literally: each agent runs in an isolated Docker container with resource limits, on your hardware, with no phone-home. Data never leaves your perimeter. Every action lands in a SHA-256 hash-chained, tamper-evident audit log that ships in the open-source core rather than behind a contract. Agent state, rollback included, is handled through git, so recovering or auditing an agent is a version-control operation instead of a vendor-specific ritual. It has native MCP support, so agents reach tools through an open protocol instead of a closed integration list.

That is the “who owns what the agent becomes” axis answered directly: the compounding asset - memory, history, self-tuning - sits inside your walls, under your version control, with receipts. And we don’t just sell that posture, we run on it. Ability AI operates 17 agents in production on the same codebase it ships, which I’ll take over a marketing number any day, because it means the vendor eats its own runtime. One of those internal systems, Cornelius, is a Self-Improving Cognitive System in production, built and run on Trinity.

I want to be fair here, because none of the following are lesser tools. They’re answers to different questions, and pretending otherwise helps nobody.

OpenHands is an excellent open-source runtime for autonomous software-development agents, with an enterprise tier that adds RBAC, SAML, SSO, and sandboxes. If coding automation is the whole job and governance can wait, it’s a natural fit - just plan for the enterprise gate before audit and access control turn into hard requirements.

Letta (formerly MemGPT) is the specialist for durable, structured long-term memory. If continuity across days or weeks is your single unsolved problem, that focus is a genuine strength. If memory is one requirement sitting alongside scheduling, recovery, and governance, the specialization cuts both ways.

Agno is a lightweight, performance-focused open-source framework with a clean path from prototype to scheduled run. Its governance layer is lighter, which is fine right up until sensitive data enters the picture - then budget for the migration.

Dust is MIT-licensed with a self-host path via its dsbx CLI, but the commercial product is managed SaaS - and that managed tier is where its strong audit-log SIEM streaming, SCIM, and SOC 2 / HIPAA-enabling certifications live. It trades sovereignty for a certified, vendor-operated surface - the right call when a compliance letter matters more than data residency, and the wrong one when residency is the whole constraint.

Bedrock AgentCore, the Gemini Enterprise Agent Platform (formerly Vertex AI), and similar cloud offerings give you scale and low operational overhead, coupled to a vendor’s cloud. That coupling is precisely the point of the ownership question: convenient to start, harder to leave.

Hermes Agent (Nous Research, MIT-licensed, self-hosted) is the one I’d point a single person to. It keeps persistent memory across sessions and writes its own reusable skills against the open agentskills.io standard, so it genuinely grows with you - a multi-platform gateway that runs on your own machine. Read it against my axes, though, and you can feel the design center: it’s built for a personal, single-user assistant, where Trinity is built for governed, multi-user production - different questions, and worth knowing which one you’re actually asking.

Every platform on this list will run your agents. That’s table stakes now, and it’s exactly why feature-column comparisons feel oddly interchangeable when you line them up. The decision that outlasts the demo is about ownership of the compounding asset - because an agent that learns on someone else’s platform is quietly compounding value into someone else’s moat.

That’s the lens I’d bring to any evaluation, and it’s the one I’ve written up in full, with the complete methodology and the platform-by-platform detail, in the canonical comparison of AI agent platforms to run agents in production. Start from your non-negotiable constraint - sovereignty, certification, coding focus, memory - and the shortlist gets short fast.