RB·11 · 2025–2026
Agentuity
In early 2025, Jeff Haynie, Matthew Congrove, Robin Diddams, Bobby Christopher and I founded Agentuity in Austin, Texas. We built a new kind of cloud for AI agents: one place where agents deploy, run, and scale, with the APIs, frontends, storage, sandboxes, evals, and observability they need already in the box.
This page is the record of what we shipped.
Why a new cloud
The cloud most of us grew up on was built for short requests and stateless transactions: spin up, serve, spin down. Agents work differently. They reason, remember, and run. An agent might work for two hours, pause to wait on a person, then pick up for another hour, calling tools and storage the whole way.
Serverless alone could not carry that, and dropping down to a raw VM pushed all the plumbing back onto the developer. We wanted agents to have what people have (time, the right resources, clear direction) and what computers have (storage, databases, coordination), as first-class parts of the platform.
We built it for two kinds of builders at once. Developers got a TypeScript SDK, a CLI, and a web console. Coding agents got the same tools, with guardrails, plus docs and onboarding written for them to read.
“It really feels like it’s the first platform that is trying to put together a system where the agents can build anything in one place. From the frontend to the backend to the cron jobs, it’s all wrapped up in an Agentuity project.”Ben Davis, after building on v1
What we built
AI Gateway
One API for OpenAI, Anthropic, Google, Groq, Mistral and more. No provider keys in code, higher shared rate limits, one bill, and token, cost, and latency tracing on every call. Bring your own keys and the gateway picks them up instead.
APIs
Standard Hono routes that deploy with your agents. Streaming, SSE, and WebSockets out of the box, with auth, rate limiting, and storage available from route context.
Frontends
React apps with types that flow from agent schemas into
useAPI,useWebSocket, anduseEventStreamhooks. Deploy beside the agents or anywhere else.
Storage
Key-value, vector search, S3-compatible object storage, managed Postgres, durable streams, and queues, all reachable from the agent’s context as tools. Ephemeral or persistent, with nothing to stand up.
Sandboxes
Isolated Linux containers for code the model writes. One call creates, runs, and destroys. Network off by default, resource limits and timeouts enforced, snapshots for instant warm starts, and runtimes for Bun, a headless browser, and coding agents like Claude Code and Codex.
Observability
OpenTelemetry tracing, structured logs, and session timelines with no setup. Prompts, responses, timing, and cost for every span, the same data in the console and the CLI, and SSH into deployed containers when you need to dig.
Evals
Evals that deploy with the agent and run on live production traffic instead of only in CI. Preset checks for safety, PII, and adversarial input, custom LLM-as-judge scorers, and results that show up as spans in the trace.
// webhook · API · cron // email · SMS · Slack · Discord const res = await otherAgent.run({ text: input.text, });Instant I/O
Email, SMS, chat, webhooks, and cron defined in code and wired up on deploy. Agents call other agents in one line, whether they were written with Mastra, LangGraph, or the AI SDK.
Workbench
A schema-aware test bench that builds input forms from your agent’s types. Same interface for local and deployed agents, one click from a run to its trace.
Deploy
agentuity deployreturns a production URL with SSL, DNS, and load balancing handled. Push to main to ship, get a preview environment per pull request, and bring custom domains configured in code.
Anywhere
Public cloud, private cloud, on-prem, multi-cloud, or edge on the Gravity Network, with one SDK and the same services wherever the agent runs.
From the console
SDK Explorer Interactive demos whose reference code runs live against real infrastructure.
Machines Live CPU, memory, network, and disk for each machine an agent runs on.
The writing
Most of what we wrote at Agentuity explained why agents need their own kind of infrastructure. The guides I wrote on orchestration, runtimes, infrastructure, observability, and deployment are preserved in the Agentuity archive.
The archive also keeps the blog, from An agent-native cloud does not mean a faster horse and Moats, the Maginot Line, and AI to hands-on posts on streaming, agent-to-agent networking, and structured output.
The team
Agentuity was founded by Jeff Haynie, Rick Blalock, Matthew Congrove, Robin Diddams, and Bobby Christopher.