Ready-made digital coworkers in a single CRM: they sell, recruit, answer customers, run the calendar, analyse calls and extend the product itself. In 5 languages. 24/7.
Six roles out of the box. Each one comes with a name, a persona, channels, tools and limits. Rename them, retrain them, replace them.
It parses job boards, filters CVs, calls candidates, runs the technical interview, agrees a time, joins the final call and hands you a finished digest.
retry decorator that retries a function on exception, with exponential backoff and at most 5 attempts.No prompt engineering. No JSON. Say “I want a support team of 3 agents” and you get 3 agents with tools, channels and rules. Edits work the same way.
Every deal comes with a summary, a next step and a list of risks. It updates in real time while the conversations are happening.
The customer is interested in a corporate subscription. Main objection: price. Decision maker: the marketing director. Competitor: a rival booking suite. Sentiment: +0.42.
Build, experiment, invent — any digital coworker for your task. Same core, different data and rules. In words, in 5 minutes.
Autonomous L1, escalation to L2 by confidence. The knowledge base updates itself.
Listens to 100% of calls and chats. Scores them, finds script violations, writes coaching feedback.
A/B tests offers in campaigns, writes posts, generates landing pages per campaign, tracks ROAS by source.
Closes paperwork, reconciles records, sends invoices, handles correspondence with counterparties. Within the limits you set.
Tracks cash flow, forecasts the balance, spots discrepancies, and answers the owner's “what am I worth right now”.
Walks new hires through their first weeks: teaches, tests, gives feedback. Customers too.
Channels, CRMs, calendars, payments, telephony, spreadsheets. Missing one? The Diva developer adds it over the API in minutes.
Ready-made connectors to the world's most popular services — out of the box, without an integrator.
Real deployments in support, sales and logistics — with numbers.

We automated support over a huge knowledge base with zero model hallucinations. Billing is per resolved user question — for the outcome, not the tokens. Plus voice support agents over telephony.

Order intake and processing, tracking, repeat and cancellation, corporate customers, voice agents. The previous implementation could not hold a flow — it looped, skipped confirmation and payment, and invented prices. We moved it to the Diva flow engine: frame gates hold each step and guards stop the agent inventing actions.
Integrations, languages and coverage — the details will appear here once the customer has signed them off.
soonA systematic, safe and measurable path — from diagnosis to optimisation inside the working business.
We map the processes and put the knowledge in order.
We assemble the structure, the flows and the agent's rules.
We connect the systems and test on live conversations.
We hand it to the team and keep improving it.
A thin typed client: describe the agent, call run(), get an answer. The agent loop itself runs on our servers.
The problems that usually cost teams weeks are handled out of the box:
A tuned knowledge base out of the box: retrieval, ranking, hallucination guards. No RAG pipeline to assemble by hand.
The best conversational flow engine on the market. Frame gates hold each step: the agent will not skip confirmation or payment, and will not loop.
The agent loop, memory and guards run with us. It scales without you, and the engine is never downloaded to the client.
Metering and billing are built into the gateway. You can charge per resolved customer question rather than per token.
SDK plus a visual builder: test a hypothesis and get a working agent in a couple of clicks.
A thin client and your own tool().execute — with your database and your secrets. Tool code and keys never leave your machine.
One sk-diva key: authentication, billing, routing and tenant isolation. A single egress that is easy to audit.
Model calls, tool orchestration, memory, RAG, compaction, sub-agents, guards and flow. The engine is never downloaded to you.
A support agent with two tools and one hard rule: never refund more than $200 — escalate instead. Switch frameworks on the right — both sides are shown in full and the code scrolls.
import { Agent, tool, guard, z } from "@diva-ai/sdk";
const lookupOrder = tool({
name: "lookup_order",
inputSchema: z.object({ orderId: z.string() }),
execute: ({ orderId }) => billing.getOrder(orderId),
});
const issueRefund = tool({
name: "issue_refund",
inputSchema: z.object({ orderId: z.string(), amountUsd: z.number() }),
execute: ({ orderId, amountUsd }) => billing.refund(orderId, amountUsd),
});
const agent = new Agent({
instructions: "You are a support agent. Look up the order first.",
tools: [lookupOrder, issueRefund],
// the hard rule — one declarative line
guards: [guard.tool("issue_refund", { when: (i) => i.amountUsd > 200 })],
});
const { text } = await agent.run("Customer 4512 is asking for a $250 refund.");import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { z } from "zod";
// + your own OPENAI_API_KEY
const REFUND_CAP = 200;
const lookupOrder = tool(
async ({ orderId }) => JSON.stringify(await billing.getOrder(orderId)),
{ name: "lookup_order", schema: z.object({ orderId: z.string() }) },
);
const issueRefund = tool(
async ({ orderId, amountUsd }) => {
// the rule has to be written imperatively INSIDE the tool
if (amountUsd > REFUND_CAP) {
return "BLOCKED: over $200 — needs escalation.";
}
return JSON.stringify(await billing.refund(orderId, amountUsd));
},
{
name: "issue_refund",
schema: z.object({ orderId: z.string(), amountUsd: z.number() }),
},
);
const agent = createReactAgent({
llm: new ChatOpenAI({
model: "gpt-4o-mini",
apiKey: process.env.OPENAI_API_KEY,
}),
tools: [lookupOrder, issueRefund],
stateModifier:
"You are a support agent. Never refund over $200 — escalate instead.",
});
const res = await agent.invoke({
messages: [
{ role: "user", content: "Customer 4512 is asking for a $250 refund." },
],
});Averaged across 2,400+ teams on Diva during 2025.
An answer to the customer in 3 seconds. Never without a follow-up.
4 hours of routine → 40 minutes. People on what matters.
Nights, weekends, public holidays — they work.
No code. No integrator. Just plain language.
You set the rules for each agent yourself: “never promise more than 15% off”, “never book a meeting without my approval”, “no messages after 10pm”. Important actions happen only with your permission. Sessions record every step, and rollback is one click.
No. A new field, report, stage, automation or a whole new agent — all in plain words. The Diva developer agent writes the code, shows a diff and runs the tests.
We bill agent actions, not seats. For a mid-sized business it starts at 9,900 ₽ per month, including unlimited agents and channels. It usually pays for itself within 2–3 weeks on a single role.
In your region. Enterprise runs in a VPC or on-premise. Models are not trained on your data.
Yes. The Diva developer maps the fields itself and suggests schema improvements. No downtime, with a dry run on a copy first.
The first agent answers customers 15 minutes after signup. A full team of 6 roles takes 1–3 days including integrations.
Three minutes and Diva sales is answering customers, Diva recruiter is filtering CVs and Diva support is closing tickets. No card. No integrator.