# A letter from our founders (/blog/a-letter-from-our-founders)

Two years of model progress have settled one argument: capability is no
longer the bottleneck. An agent today can plan, write, and use tools well
enough to do real work. What it still cannot do is operate like a member of
your organization — hold the right access, remember what your team knows,
spend within a budget, leave a trail you can audit. The bottleneck has moved
from the model to the runtime underneath it.

Agents are becoming the new unit of compute, and infrastructure has always
arrived one beat after the unit of compute explodes: the PC got the operating
system, the web got the cloud, and app builders got platforms like Firebase
and Supabase. That beat is now.

Yet every developer who adopts an agent this year hits the same wall within a
week: the agent is capable, and it is standing in an empty room. Every
external system it should touch means an OAuth application to register,
credentials to custody, permissions to reason about, isolation to engineer.
You adopt agents to deliver outcomes; the effort drains into configuring
them. We rebuilt that layer from scratch three products in a row before
accepting that the layer itself was the product.

What we believe is simple: an agent is a process you cannot let run bare.
Every computing era ends up with an operating system, and an operating system
is two commitments — it owns the resources, and it mediates every privileged
operation. Programs don't manage the hardware; they make system calls. Agents
deserve the same contract: never carrying a raw credential, never spending
without a ceiling, never acting without a record. Not because agents are
untrustworthy, but because infrastructure that depends on trust doesn't scale
past one laptop.

That contract should hold whichever agent you choose. We're starting with
the agents you already use, giving them access to your organization's tools,
knowledge, and resources. When you find a better agent, it should inherit
that foundation and get to work.

We'll also build a hosted workspace where you can run agents on CoreSpeed.
Agents you bring and agents we host will share the same foundation. Bringing
your own agent will remain a first-class way to use CoreSpeed.

As that foundation grows, we expect agents to build more of the software
they use. Connectors to today's SaaS are our Rosetta: when Apple changed
chips, Rosetta let yesterday's software run on day one while the ecosystem
went native. Same here. Connectors make agents useful in the world as it is
— and what crosses the bridge stays.
Identity, grants, memory, budgets, and the audit trail accumulate in your
org's state layer, not in any single tool. We have already rebuilt our memory
engine twice without moving that layer once. Engines swap. What your
organization owns doesn't.

The world going native is the part we find genuinely exciting. Software built
for human limitations puts a UI between people and the database; software
built for agents inverts that — governed data agents can hold directly, and
interfaces generated for humans on demand. Generic SaaS was one-size-fits-all
because software was expensive to make. Agents end that constraint, and
custom software becomes something every team can own. That is the long arc.
We are walking it one shipped component at a time, in public, starting with
[the apps, memory, and controls we're introducing today](/blog/introducing-corespeed).

Make something agents want.

— Milton Yan, Founder & CEO · Hao Su, Co-Founder & CTO