# Introducing CoreSpeed (/blog/introducing-corespeed)

We're excited to introduce **CoreSpeed** to the world. For the vision behind
it, read the [letter from our founders](/blog/a-letter-from-our-founders).

Software was built for people. The next user is an agent. We're building the
foundation it needs to work inside your organization — whichever agent you
choose to run.

Today, agents run on bare metal.

Credentials get pasted straight into the process. Permissions get patched
together for each agent. There is no shared filesystem — spin up another
agent, and it starts without the files, memory, or configuration it needs.
There are no resource quotas — a runaway loop can burn $300 over a weekend
before anyone notices.

Decades ago programmers managed hardware directly too. Then the operating
system moved in: one layer that owns the resources, mediates every privileged
operation, and doesn't care which program you run on it.

That's what we've been building for agents. Model vendors give your agent its
intelligence. CoreSpeed gives it everything else it needs to act safely in the
real world.

## One endpoint owned by your org \[#one-endpoint-owned-by-your-org]

CoreSpeed gives any agent — local, cloud, or still running after your laptop
closes — its full working kit through a single MCP endpoint.

The unit of ownership is your organization. Grants, memory, budgets, and the
audit trail live in the org. Bring in a different agent, and the shared context
and connections are already there.

Agents are first-class citizens in CoreSpeed.

We believe agents should have their own place in an organization, with the
same clarity about identity, access, and responsibility that we expect for
people. That belief shapes how we build CoreSpeed.

Each Agent Identity has its own credentials, private memory, and a record of
its actions, with a human owner responsible for it. It can use the connections
shared with your organization, while your private connections stay private.

## Your apps without the OAuth homework \[#your-apps-without-the-oauth-homework]

Every service you connect to an agent today costs you the same ritual:
register a developer account, create an OAuth app, wait through an approval
queue, then babysit refresh tokens forever. You repeat it per service, and the
result is welded to a single agent on a single machine.

CoreSpeed collapses the ritual into one action. Authorize an app once in the
dashboard, and every agent in your org gets it through the same endpoint.
Each member holds their own grants — the activity log shows who did what — and
the same app can carry multiple accounts side by side. For services we don't
host yet, register your own remote MCP server and it joins the same surface,
under the same identity and the same log.

One property matters more than convenience: \**your agent never touches a raw
credential.*\* Tokens live in the platform's custody. The agent asks for an
action; the platform performs it with the right account and writes it down.
In August, Cloudflare [open-sourced its own take on this
pattern](https://blog.cloudflare.com/cloudflare-os/): credential-proxying
"Gatekeepers", agents never holding tokens. Credential custody is trust
infrastructure, not an integration convenience.

## Memory that belongs to the team \[#memory-that-belongs-to-the-team]

An agent that forgets everything between sessions is a contractor you have to
re-onboard every morning. CoreSpeed memory is durable and lives at two scopes:
shared, where your team's conventions, decisions, and context compound; and
private, for what only you should see. Any agent you sign in can recall it and
add to it — the memory belongs to the org, and every agent you run works from
the same one.

## Batteries included \[#batteries-included]

These tools are built into CoreSpeed. No extra provider accounts or API keys
to manage; they draw from the same credits and appear in the same activity log.

### Media \[#media]

Generate and understand images, audio, and video. Upload media for your agent
to work with, and get generated files back as links you can open and share.

### Web \[#web]

Search the web for source material and turn individual pages into clean
Markdown your agent can read.

### Social research \[#social-research]

Explore public posts, profiles, comments, and trends across YouTube, Instagram,
TikTok, X (formerly Twitter), Reddit, and RedNote. No social account needed.

## Budgets and a ledger \[#budgets-and-a-ledger]

Agents are loops, and loops sometimes run away. Set a spending limit in
CoreSpeed, and a runaway loop hits that limit before it empties your wallet.
Every action and every charge appears in the activity log, so you can see
what your agents did and what it cost. Pricing combines a subscription with
usage-based credits.

## Any agent can log in \[#any-agent-can-log-in]

Like any good OS, CoreSpeed doesn't care whose program you run. Claude Code,
Codex, Cursor, a harness you wrote yourself — anything that speaks MCP signs
in and gets the same kit. This matters most the moment your agent leaves the
laptop: when it keeps working after the lid closes, when it's one of five
running in parallel, when it works for a team. Wherever it runs and
whoever made it, the accounts, the memory, the budget, and the log are already
there — because they never lived in the agent to begin with.

## What's next \[#whats-next]

An agent needs an identity, a place to keep its state, somewhere to run, and
ways to act in the world. An Agent OS brings these together and manages what
the agent may do, what it may spend, and the record of its work. That's the
full CoreSpeed we're building.

Today's release puts the first parts of that system in your hands. Here's the
bigger picture, including what's still ahead.

Smart approvals will be the next piece: describe in plain English what your
agents may do, what needs your approval, and what must never happen. CoreSpeed
will turn those instructions into rules you can review and enforce them before
an action runs.

## Get started \[#get-started]

The docs are at [corespeed.io/docs](https://corespeed.io/docs), and, fittingly, every page —
this one included — is also served as plain markdown for agents:
[/llms.txt](/llms.txt).

We're building this in public, one component at a time. Come tell us what
your agents need next — the team is on
[Discord](https://discord.com/invite/NdBHBvDRXX).