beta · live now
Hyperbolic
A runtime for agents that pause, switch, and finish what they start.
Tasks are processes — stateful coroutines that pause for input and resume on signal. The Task Engine runs them like a micro-kernel; the Agent Supervisor decides which to run and what's in scope. Conversations survive long waits, third-party callbacks, and task switches — without losing state.
No LLM expertise required
You don't have to become an LLM company to ship a conversational product. Your existing API, data, and business logic stay exactly as they are — we chain them into a conversation, run the model, and constrain it so all it can do is render: speaking what you tell it to say, like a human.
Your existing endpoints, databases, and services don't change. We chain them into a conversation graph — no migration, no rewrites, no rebuilding the parts of your stack that already work in production.
No prompt engineering, no embeddings, no fine-tuning, no agent debugging. The hard parts of working with a model are already solved. You only ever write one kind of instruction: tell the model what to render.
tell_user("Payment failed: card ending 4242 expired. Retry: /pay/4711")The model can only say what your task tells it. Facts come from your API; decisions come from your code. The LLM is a renderer that turns structured data into a natural sentence — it can't invent an order number or promise a refund you didn't authorize.
Your product becomes conversational. You don't become an LLM company.
What's different
Existing agent frameworks treat tasks as fire-and-forget tool calls and lose state the moment something pauses. Workflow engines have real state machines but no conversational surface. The Conversational OS does both — and adds four things most stacks don't.
Tasks yield via Python coroutines and wake on real events, not timers. Long waits are free — hours or days cost nothing.
A user clicking submit on a third-party redirect resumes a task that's been waiting since yesterday. Data flows in from the outside without restarting anything.
Mid-conversation the agent can pause one task, jump to a more urgent one, and return. Each task's state is preserved — no replay, no lost context, no awkward "where were we?"
A redirect node opens one of your existing pages inside the chat as a side panel — forms, dashboards, payment widgets. OAuth2 brokers the result server-to-server, so your stack keeps paying off without exposing tokens to the client.
What is a Conversational OS
The Task Engine is a micro-kernel that runs stateful coroutines — tasks that pause for input or external signals and resume exactly where they left off. The Agent Supervisor sits above it: picking which task runs, switching when the conversation pivots, and enforcing what each task is allowed to do. Together they let an agent hold its place across anything that takes more than a single turn — a clarifying question, a callback three hours later, an urgent pivot.
A micro-kernel for coroutines — event-loop-driven, specialized for state that pauses and resumes.
Each task is a graph of nodes. A node runs, yields when it needs user input or an external signal, and the engine wakes it the instant that data arrives — minutes, hours, or days later. When something goes wrong, control jumps to a recovery node you chose. No polling, no try/except trees, no replay rebuilds.
The layer above the kernel. Picks which task runs, switches between them, and enforces what each is allowed to do.
The agent picks tasks based on the conversation, swaps them when the user pivots, cancels them on demand, and enforces guardrails on what they can do. Mid-conversation context switches don't lose state. Publish once and share one URL — your end users get the same agent your team configured, with no login and no install.
What a task is made of
Every task is a graph; every node is one of three primitives. Compose them into a one-step lookup or a multi-stage onboarding flow — the same three pieces fit anywhere from a stub to a production workflow.
Pull data, push data, kick off a job. Standard HTTP — your existing endpoints just work, no SDK to integrate.
A phone number, a date, a confirmation. The conversation yields until the user answers — minutes, hours, whatever it takes.
Open one of your existing pages — a form, a dashboard, a payment widget — inside the chat as a side panel. The user interacts with what you already built; the task waits.
OAuth2 · server-to-serverGet started
The product has two halves you can pick up independently. Both sit on the same runtime, share the same conversation, and read the same task graphs.
Chain api_call, collect, and redirect nodes into workflows. Visual editor; the graph runs on the Task Engine.
Coming soon Agent LabGive a set of tasks a voice, guardrails, and a shareable URL. The Agent Supervisor picks which task runs and keeps the conversation in scope.
Enter Agent LabTry it
A pre-baked demo agent will pause for your input, call out to a mock external service, and resume — all without losing state. The URL changes silently as the conversation begins.