At Blockdaemon, teams ask business questions in their chat tools and AI assistants. Behind the scenes, Coral turns each question into a short, read-only program that runs live across the systems we run the company on.
At Blockdaemon, teams ask business questions in their chat tools and AI assistants. Behind the scenes, Coral turns each question into a short, read-only program that runs live across the systems we run the company on.
This blog covers where we started, the options we weighed, why we chose Coral, and what changed.
Blockdaemon keeps a clear record of how business data runs. Our own services track subscriptions, products, and usage. The platforms we use for billing, CRM, product analytics, and project docs each hold their part of the picture. The data was sound. What we wanted was one way to ask a question across all of it.
That is harder than it sounds. Each system has its own API, with its own login, paging, and filters. Each one also describes a customer in its own terms. A question that touched two systems needed an engineer to write a script or pull an export. Revenue, customer success, and product teams had strong questions, and our data could answer far more of them than we had time to handle by hand.
AI assistants meant everyone now had an easy way to ask, and we wanted every assistant to reach the data that could answer.
The second option has a quiet flaw. Agents hit the same API problems developers do, but they hide them. An agent that reads only the first page of results will report it as the full answer. We wanted one way to expose all of our data, without a new integration for every new question. That pointed us to the third option.
Coral gives agents one place to find and call the APIs our business runs on. Instead of making one tool call at a time, an agent writes a short TypeScript program. The program calls each system it needs, pages through the results, joins the data, and returns only the answer.
That design solves the problems above. Paging and joins happen in code that an engineer can read, not across a long chain of tool calls the agent might cut short. Raw API responses stay inside the program and do not fill the agent's context.
Coral also matched how we needed to run it. It is read-only by design, it runs self-hosted inside our own infrastructure, and it speaks MCP natively. That let it plug straight into our agent gateway and the AI tools our teams already use.
Adding a source takes a declarative spec. Our own services are exposed the same way as off-the-shelf platforms. We now write one spec per system, instead of new code for every question.
Users don’t need to see the code. Say someone asks their assistant: "Which customers are over their plan usage this month?" The agent writes this program through Coral:
const usage = [];
let cursor;
do {
const { data } = await coral.providers.subscriptions.listUsage({
month: "2026-10",
cursor,
});
usage.push(...data.items);
cursor = data.next_cursor;
} while (cursor);
const overLimit = usage.filter(c => c.usage > c.plan_limit);
return await Promise.all(overLimit.map(async c => {
const { data: deals } = await coral.providers.crm.listDeals({
company: c.org_name,
});
return {
customer: c.org_name,
usage: c.usage,
limit: c.plan_limit,
stages: deals.map(d => d.stage),
};
}));
First, the agent finds the right operations. Coral gives it a discovery-first workflow. It searches the operations and functions it can use, then looks up the TypeScript signature of each one before it writes any code. Next, it writes the program, including the join from our subscription service into CRM deal data. Coral runs it live against the source APIs in an isolated sandbox, and the user gets back a list of customers with their current usage.
Saved functions also guide the agent. Common questions, like "what's assigned to me" or "which customer has the highest usage," already have a function. When a program answers a new kind of question, the agent can save it as a function too. The next agent that gets a similar question finds that function and calls it in one line:
return await coral.functions.revenue.overLimitCustomers({ month: "2026-10" });
Every request passes through Blockdaemon's Enterprise Agent Gateway before it reaches Coral. Users sign in with their corporate identity, and access is limited to approved business groups. Coral itself is never exposed directly.
We are just as careful about what goes in. Only read endpoints are exposed. Key material and documents that could hold personal data are left out by design.
Teams now get live answers that cross systems, in plain English, inside the tools they already use. Revenue, customer success, product, and engineering no longer wait on scripts or exports for everyday questions. Bringing a new system online takes a spec and a secret. Because each question runs as one program, agents make fewer tool calls, use fewer tokens, and return fewer answers that are quietly wrong.
The work is no longer thrown away after one use. A program that answers a new question can become a function that the next agent reuses.
The engineers who used to write one-off scripts now write specs, once per system.
Tell us about your market access and infrastructure requirements. Our team will be in touch to help you implement the right solutions for your institution.