Why Radioso
Agents that answer, act, and hand off — inside the rules you set.
A Radioso agent works out how to help, and the rules you author decide what it may do while it does that. It answers from your own data with citations, carries a request through to the action it needed, and gets a person when a person is what the moment calls for. When it gets something wrong, you can see which rule steered it and fix that. One agent, every surface, one debug loop.
Run locally in 5 minutes →It carries a request end to end
Talking is the cheap half. The job is finishing the thing the person came for.
Directives are standing rules that steer how the agent behaves. “When the customer sounds anxious, slow down and confirm before doing anything.” You write the rule once; the agent applies it whenever it fits, on every surface, in every language. Directives steer; when you want the agent to actually do something, that is a skill’s job.
Routines are multi-step flows the agent runs across turns. A return request, an onboarding check, a “collect these three things and file a ticket” — you write the steps in plain language, drop in a chip where the flow needs to collect a value, call a tool, or branch, and Radioso compiles it into something the engine runs and resumes turn to turn. Validate it, publish it, and it is live on every surface — writing the steps is the whole job.
And when the agent should stop talking and do something, it does: call a tool, fire a webhook when a routine finishes, or hand the conversation to a real person. The built-in “contact a human” flow is itself just a routine — collect an email, collect a message, submit, confirm.
Every step it takes — which directive steered it, which tool it called, which routine step it is on — lands in the same turn trace as the answers. If it does the wrong thing, you can see why.
We call this shape guided autonomy: you don’t have to enumerate every path in advance, and you don’t have to accept whatever the model decides on its own.
Grounded by default
The answering half has its own rule, and it is on from the start. When the agent has evidence in your data, it answers and cites the source. When it does not, it says so.
This is not a marketing claim. It is the default behavior of every Radioso agent, and it works the same way across every surface: your website chat, your API, your MCP server, and your public link. If you can break it, we want the bug report.
Debug the agent, not the framework
Every agent gets a wrong answer eventually. The question is whether you can find out why and fix it without paging an ML engineer.
In Radioso, every answer shows you the retrieval steps that produced it: which documents were considered, which chunks ranked highest, and which made it into the final context. If the answer was wrong, you can edit the source document, replay the question against the updated corpus, and watch the next answer get better. No vendor ticket. No retraining. No guessing.
One agent, every surface
Your customers ask questions on your website. Your sales team wants the same agent in a shareable link. Your docs site needs an embedded chat widget. Your support team queries through your API. Your engineers want the same agent in Cursor and Claude Desktop.
Most teams build five different integrations against five different stacks to make this happen. With Radioso, you build your agent once — its data, its procedures, its persona. Every surface talks to the same agent, with the same answers and the same debug loop when something goes wrong. Update a document or a procedure, and every surface updates with it.
Whether we are the right fit
We would rather lose a deal than win the wrong one, so here is where the edges are.
Knowledge you curate, plus systems you call. The agent answers from material you publish into Radioso — docs, policies, product pages, crawled sites — and grounding is only as current as what you have published. Live state that changes minute to minute, like ticket status or inventory, belongs on the other side of a skill: you connect the system over MCP and the agent queries it at the moment of the question. Deciding which knowledge is curated and which is fetched live is a real design call, and it is yours to make.
Agents you put in front of people. Every part of this product is shaped around a conversation someone is actually having: a persona, standing rules, a flow that survives across turns, a handoff to a teammate. If the thing you need is a workbench for assembling arbitrary AI pipelines that no human talks to, you want a tool built for that job.
You own and operate the stack. Radioso is open source, runs on your own infrastructure, and keeps every conversation in your Postgres. That also means you run it: upgrades, capacity, model keys, and the on-call pager are yours. Some teams want exactly that. Some teams would rather pay someone else to hold it, and that is a fair trade to want.
If those trades read as the ones you would make, keep going.