The agent is a file. Define it once, call it from anywhere.
One declarative config turns an objective into a production agent — and the same agent answers from your app, your Slack, and your back office. Easy to set up. Reliable everywhere.
Imagine the whole agent is one file you can read.
A short config says which model it uses, whether the run is durable or ephemeral, how it runs, what happens before and after it acts, and who is allowed to call it. That file is the agent. And the same agent answers a request inside your product, replies in a Slack channel, and runs unattended in a back-office job — from one definition.
That is the whole pitch: define the agent once, call it from anywhere, and trust it everywhere.
Every team is re-wiring the same agent
The models are extraordinary. The integration is the tax. Every surface you want AI in — the proprietary app, the Slack bot, the back-office workflow — gets its own bespoke wiring, its own retries, its own failure handling, its own access rules.
So you don't really have one agent. You have N copies of it, scattered across N codebases, drifting apart as each one is patched in isolation — and N separate places where reliability can quietly break. The hard part of production AI was never the model. It was making the same agent dependable everywhere you call it.
The agent is a file
The shift is simple: the agent stops being glue code you maintain in every app and becomes one declarative config — the unit you move, not the plumbing you rebuild. One file describes the job end-to-end: the model it uses, whether a run is durable or ephemeral, how it runs (a single pass, an iterative loop, or a long-horizon workflow), what happens around every action with pre- and post-process hooks, and which user groups are allowed to call it.
Read that list, then forget it — because the point isn't the fields, it's the workflow. Declare it. Call it. Trust it. Configuration is the product: the agent is a file you can read, review, and move, instead of a wiring diagram you reverse-engineer six months from now.
Call it from anywhere
Once the agent is a definition instead of an integration, the call site stops mattering. Embed it in your proprietary app. Wire it into a Slack bot. Trigger it from a back-office workflow that runs while everyone is asleep. It's the same artifact every time — only the caller changes.
You don't rebuild the agent for each surface; you call the one you already defined. Whatever the use case, the agent is identical and the behavior is consistent. Define it once; let the use case decide where it runs.
One shot, or a long horizon
Autonomy isn't all-or-nothing — it's a spectrum the config selects, and one setting moves you along it. A one-shot run is a single clean pass for a bounded ask. An agentic loop plans, acts, observes, and repeats for work that needs iteration. A long-horizon workflow is a durable, multi-step run that survives interruptions and steers itself over hours.
Same file, one field, a different level of ambition — and the runtime handles the rest. The short end is convenient; the long end is the hard part nobody else holds together. We've pointed a single long-horizon run at one objective and watched it sustain ~1.5 billion tokens of context across ~50 hours, re-planning itself 201 times to completion. One-shot autonomy is a setting. Long-horizon autonomy is the reason it holds together.
Easy is the setup. Reliable is the runtime
Anyone can make AI easy. Easy and reliable is the category — and reliability is what the config buys you, because it runs on a durable, auditable runtime. Durable: a run survives interruptions, failures, and retries instead of collapsing; when something breaks, it recovers surgically rather than restarting from zero. Auditable: every action is admitted as a typed change on a provenance ledger, so you can prove exactly what the agent did and replay it.
And governed: the same access rules and the same pre- and post-action hooks travel with the definition, so the agent behaves the same in your app, your Slack, and your back office — not "the same most of the time." It keeps coherent state across a long run instead of losing the thread halfway through. Stop re-solving reliability per surface. Start inheriting it from the file. Anyone can make AI easy. We make it easy AND reliable.
Where this goes
The unit of AI work stops being a prompt buried in an app and becomes a definition you move around. Anyone can write the config; any team can call it for their own use case; everyone gets the same guarantees. The person who sets it up doesn't have to be the person who uses it, and the surface it runs on doesn't have to be the surface it was born in.
That is what makes AI usable in production, not just impressive in a demo: a portable, governable artifact that's as trustworthy on its thousandth call as its first. Define the agent once. Call it from anywhere. Trust it everywhere.
Get early access
Coresource is moving into the hands of a first set of teams now.
We're also hiring the engineers and researchers who want to build the reliable-AI era. If that's you, come build it with us.