Primitives, not products
Why Cradle Research builds the parts autonomous systems are made of, and how Glove and Station fit together.
Our tagline is four words and a period: Building Primitives for Autonomous systems. This post is the longer version.
We are a small research shop. We ship two things people can use today: Glove, an open-source TypeScript stack for building agent applications, and Station, a background jobs framework that keeps those applications running. Everything else we do is in service of those two, and both of them are in service of one belief.
The belief
Autonomous systems are not built. They are assembled.
Nobody who has shipped a real agent system got there by writing an agent. They got there by writing the twenty things around the agent that nobody talks about in demos. Somewhere for it to keep what it knows. Somewhere for it to do its work without dumping every intermediate result into the context window. A way to reach the outside world. A way to wait for something that will not resolve this turn. A way to talk to a second agent without inventing a protocol. A clock. A queue. A place to see what happened when it goes wrong at three in the morning.
Every team rebuilds these. Most of them rebuild them badly, under deadline, welded to whatever model and vector database they happened to start with. The result is a system that works exactly once, in the demo, and is never composed with anything again.
We think the twenty things are the product. The agent is what you get for free once you have them.
What a primitive is
We use the word deliberately. A primitive is a part that is small enough to understand completely, opinionated about exactly one thing, and indifferent about everything else. It composes with parts it has never met. It ships with the boring version of itself so you can start today, and it lets you replace that version with your own without touching the code that uses it.
Glove's own docs put the rule better than we can. The parts a framework should own are the ones that are the same everywhere: the loop, the tool contract, how a result is split between the model and the screen, what happens when the window fills. The parts it should not own are the ones where you already made a decision. Your database. Your auth. Your queue. Your vector index. A framework that ships those is asking you to run a second copy of infrastructure you already have.
So Glove ships an in-memory reference implementation of nearly every adapter, and a production version of almost none. That is the one opinion it really holds.
The parts
Here is the shape of what we build, by the question it answers for an agent.
Where do I keep what I know? Glove's memory package is five subsystems, not one: an entity graph with identity keys, an append-only episodic timeline, a resource filesystem, ambient context injected every turn, and forms for collecting structured data by talking. We wrote a whole post on why it is five and not one.
Where do I do my work? The working environment: a sandboxed, persistent virtual filesystem with a script runtime. A tool call ends when it returns. A script stays. That post is here.
How do I reach the world without drowning in it? The scratchpad turns a catalog of tools into a relational database behind one execute_sql tool. Code execution turns the same catalog into one sandboxed REPL. Both exist because the tool list is the wrong abstraction for an agent with more than a dozen capabilities.
How do I wait, and how do I talk to my peers? The inbox is a persistent mailbox for requests the agent cannot resolve now. Mesh is inter-agent messaging built entirely on top of it. Mailboxes for agents.
Who keeps me running? That is Station. Signals for isolated, typed, retried jobs. Broadcasts for DAG workflows. Beacons for the long-lived processes an agent session actually is. Schedules that live in code or in the dashboard. Why Station exists.
Each of these is usable alone. None of them require the others. That is not an accident of packaging. It is the whole point.
And one product
The title of this post is a little unfair, because we do ship a product. Proxima is a team of droids for small teams: you build each one, wire it into the tools you already use, and let it handle the grunt work while you go do something more important.
We built it for the same reason a foundry casts its own bell. Proxima is assembled from the primitives above and almost nothing else. Its droids are Glove agents. Their memory is the five-part memory package. Their documents come out of the working environment. They talk to each other over Mesh and wait on the world through the inbox. Every scheduled spawn, every ingest, every long-lived connection to Discord or Telegram is a Station signal or beacon. When a primitive is awkward, we feel it first, in our own product, before anyone else does.
That is the test we hold ourselves to. If the parts cannot build a product a small team pays for, they are not primitives yet.
Why open source, why TypeScript
Open source because primitives that cannot be read are not primitives, they are dependencies. If you cannot open the box and see why the entity graph refused a write, you cannot trust it with the thing your agent believes about a customer a year from now.
TypeScript because that is where the applications are. The interesting agent systems are not notebooks. They are products with a frontend, a backend, a database, and a team that has to maintain them. Glove's display stack renders React components mid-conversation. Station's signals are Zod schemas with a handler. The whole stack is one language, from the model adapter to the button the user clicks.
Measured, not guessed
We try to hold ourselves to a rule we borrowed from the working environment's README: a design claim is cheap. Only claims with numbers behind them get asserted.
So when we say the scratchpad reduces peak context, we mean that across ten mocked-but-real services and thirty-two tools, the scratchpad arm used two to four times less context than folding the tools in directly, and at production scale, forty servers and 367 tools, the tool-folding baseline became the least accurate arm at twelve times the context. When we say cheap models can drive it, we mean a model billed at nine cents per million tokens scored seven for seven on the same tasks as the frontier. The transcripts are in the repo. The total spend for every experiment was under six dollars.
We will get things wrong. The papers in the Glove repo each have a section listing what did. But we would rather publish a number and be corrected than publish an adjective.
What this is for
We want a world where an autonomous system is something a small team assembles in a week from parts that already work. Not a platform you move into. Not a hosted control plane with your data on it. Components you pick up, read, and compose.
That is what "primitives for autonomous systems" means. The rest of this blog is us showing our work.
