What we are building for the agent-to-agent era
Today an agent answers a call, reads a record and books an appointment. The work ahead is what happens when the other side of the conversation is also an agent: one that has to be found, identified, trusted, paid and held to an account. This page is the agenda we are engineering against, and what stands where.
Somewhere in the next few years, the party on the other end of the line stops being a person. Agents will find each other, hire each other and settle up in the time a phone takes to ring — and the platform underneath that has to be built now, not when it arrives.
Your agents will hire other agents, and settle it without you
The unit of work stops being a person calling a tool. It becomes one agent finding a second, agreeing terms with it, having the work done and clearing the bill, inside seconds and on the record. The engineering question is not whether that happens but whose boundary it happens inside, and under whose control.
The pieces this is assembled from are in production today: tools with typed parameters, MCP discovery, per-tenant isolation and a full audit trail. The circuit that turns them into a transaction between two parties is what we are building.
Discovery instead of failure: An agent that needs a capability it does not have looks it up rather than apologising to the caller: a registry of what other agents can do, what it costs, what it is permitted to touch and how it has behaved.
Terms before execution: Price per call, a latency ceiling, the data it may see, what it may retain and for how long, agreed as a machine-readable contract before the first token is spent.
Settlement as a record: Metered per call and cleared automatically, with one line per transaction that finance can read and audit can replay. Automatic payment without an automatic record is not a feature, it is an exposure.
A funded, bounded mandate: An agent cannot spend what it was not funded for, cannot reach data it was not granted, and cannot extend its own mandate. The interesting part of autonomy is the edge of it.
A market for capabilities, bought by the permission rather than by the seat
If agents are going to hire each other, something has to list what is on offer. Not an app store of finished assistants, but a catalogue of capabilities — a skill, a tool, a data source, a whole agent — each with the scope it runs under written into the listing.
Reusable tool and skill libraries, MCP server discovery and per-tool permission scopes are in the platform now. The market layer over them — listing, pricing, provenance, review — is the research.
Listings, not installs: A listing says what the capability does, what it costs, which modalities it covers and what it needs access to. Everything a buying agent has to know before it commits, in a form a buying agent can read.
Granular by construction: Scope is per tool, per field, per rate limit, per retention window. What changes hands is a permission with an expiry, which is the only version of this that survives a security review.
Your own library first: The first market most operators need is an internal one: the tools, graphs and integrations your own teams already built, listed once and reused across departments instead of rebuilt per project.
Provenance and review: Who published it, what it was tested against, how it has performed and what it was caught doing. A marketplace without that is a supply chain with no inventory control.
Agents need names, not API keys
A shared secret says a request is authorised. It does not say who is acting, on whose behalf, under what mandate, or for how long — and those are exactly the four questions an auditor asks about an autonomous system. An agent identity layer answers them by construction.
Every agent, tool call and conversation is already attributable inside a tenant, and MCP is how agents reach external capability today. Identity that travels between operators, with delegation and revocation, is in prototype.
A name that can be revoked: Each agent is an identity in its own right: issued, attestable, and able to be withdrawn in one place without rotating a secret across forty integrations.
Acting for someone: Delegated authority is explicit and narrow: this agent acts for this account, for this purpose, until this time. Borrowed rights, never inherited ones.
Coordination over one protocol: MCP is how an agent reaches capability it does not own. We are extending the same idea sideways: agents that announce themselves to each other, hand work over and report back, rather than one bespoke bridge per pair.
Attribution, not logging: Every action traces to an identity, a mandate and the conversation that triggered it. That is the difference between an audit trail and a pile of logs, and it is the thing regulators will ask for first.
Discovery, marketplaces and automatic settlement all assume an answer to “who is this, and what may it do”. Identity is not the feature that follows the agent economy; it is the one that makes it safe to switch on.
One meta-agent, and the best instrument for each job behind it
No single provider is best at speech, at vision, at long-horizon reasoning, at retrieval and at code. The Kilevel harness already treats models as interchangeable parts; the KI Agent is the layer above it that chooses, per task and per modality, from a handpicked set — and keeps looking for what is not in the set yet.
Multi-provider operation is production behaviour today: speech, language and transcription models are selected per agent and swapped without touching a graph. A meta-agent that makes that choice autonomously, per turn, is in prototype.
Best of breed, not house brand: Each category is filled by whatever currently wins it — speech, vision, reasoning, retrieval, code — chosen on measured behaviour rather than on who owns it. A platform that always picks its own model is optimising for the wrong party.
Chosen per task, not per tenant: Routing happens at the level of the step: the model that handles a delicate objection is not the one that extracts six fields from a form, and neither needs to be the one configured last quarter.
Discovery as a standing process: New agents, skills, tools and MCP servers are found, tried against your own cases and promoted or dropped. The arc is open at one end on purpose.
Our own libraries in the same set: Kilevel’s own state graphs, guardrails and operational tooling compete in the same selection as everything else, and lose it where something else is better. That is the only way the claim stays honest.
Agents that build the next agent, and remember what the last one learned
Self-improvement is only a claim worth making if something measures it. The Kilevel assistants already build and rewrite agents end to end; the research is the loop around that — a generation that is promoted because it scored better against your own cases, on a memory substrate the next one inherits.
Assistants that create and update agents, tools, integrations and whole state graphs are in production, as are AI-to-AI simulations that test an agent against adversarial personas. What is research is the closed loop: promotion decided automatically on the result.
Recursive construction: An assistant that can author a state graph, its tools and its integrations can author its own successor. Each generation carries more structure on the same footprint.
A gate, not a gradient: Promotion is decided by measurement against your own traffic and your own awkward cases. Without that bench, self-improvement is drift with better marketing.
Memory with a shape: Per contact, per account, per operation: what was agreed, what was tried, what annoyed them last time. Memory that cannot be inspected or deleted per subject is a liability rather than a capability.
Autonomy with an edge: Guardrails, tool-level limits and a human handover point stay in force across every generation. An agent may change how it works; it may not change what it is allowed to do.
The public side of your business card, answering when you cannot
A card gives someone a number and hopes you pick up. The other side of it is an assistant with its own identity that is always reachable: it knows your calendar, your commitments and the history of this particular conversation, and it hands you the outcome instead of the interruption.
The parts are shipping: inbound voice and chat agents, calendar and CRM integration, follow-up calls, and work agents running in the background. A single personal assistant with a public identity of its own, across a whole team, is in prototype.
An identity of its own: Not a voicemail and not a bot behind a form: a named assistant that can be addressed directly, states what it is, and is accountable to the person it works for.
Threads, not channels: One continuous thread per person, whether they called, wrote or booked. The assistant tracks the communication; the channel it arrived on is an implementation detail.
One per person, one record per team: Assistants that hand over between colleagues, share what the team is allowed to see and keep one history of the account rather than five private ones.
Outcome, not interruption: It books, reschedules, chases the missing document and escalates the one thing that actually needs you — which is the only measure of an assistant that matters.
None of this is a reason to wait, and none of it is a separate product. Every thread on this page is built on what the platform already does in production: state graphs, typed tools, MCP discovery, per-tenant isolation, guardrails and a complete audit trail. The agent economy will be won on foundations, not on demos — which is why we are engineering the foundations in the open and marking honestly what is not there yet.
Bring us a problem
that does not have a product yet.
Most of what is on this page started as a question from an operator running something at a scale we had not seen. If one of these threads is on your own roadmap, we would rather build it against a real case than a hypothesis.
Engineered in Germany. Deployable in our cloud or inside your own estate, which is what makes research like this testable on real traffic rather than on a sandbox.
Frequently Asked Questions
Everything you need to know about Kilevel.
Kilevel is a full-stack AI operations platform for businesses that communicate at scale. It unifies phone calls, WhatsApp, SMS, email, and web conversations under a single AI-native operating system, with visual workflow automation, omnichannel inbox, AI conversation analysis, and real-time operational control. From solo operators to enterprise teams, Kilevel runs autonomously across your entire communication stack.
Legacy IVRs follow rigid scripts. Chatbots handle text in isolation. Kilevel is an AI-native operations platform that handles real phone calls, WhatsApp, SMS, email, and web conversations simultaneously, with genuine contextual understanding. Agents adapt mid-conversation, book appointments, trigger follow-up automations, analyze every interaction, and hand off to humans when appropriate. The entire stack runs from a single platform: inbound queue, outbound campaigns, post-call intelligence, and operational reporting.
Yes. You can build and test your AI agent for free using our library of ready-made industry templates or by starting from scratch. Design call flows, configure channels, and connect integrations before going live. When you deploy, you pay a monthly subscription fee, which already includes a bundle of free AI minutes per month. Any usage beyond the included allowance is billed on a pay-as-you-go basis. No seats, no surprise fees.
No seats, no per-user charges. Kilevel combines a monthly subscription with usage-based pricing: each plan includes a pool of free AI minutes per month, and additional usage beyond that is billed at a per-minute rate. Building, testing, and configuring agents is free. Once live, costs scale predictably with your volume. Enterprise customers with high-volume commitments can discuss custom pricing agreements.
Most teams ship their first agent within a day. Kilevel comes with a library of industry-specific templates that cover the most common call flows and channel configurations out of the box. Pick a template, configure your agent's persona and rules, connect your tools, and deploy, no code required. Custom flows are built visually, and the AI flow assistant can generate an entire flow structure from a single descriptive sentence.
Kilevel gives your team leverage, not a replacement. AI agents absorb the volume of after-hours calls, common questions, appointment bookings and multilingual conversations, so your staff can focus on complex cases that genuinely need a human. Built-in sentiment analysis and configurable handoff triggers mean the AI always knows when to step aside.
The platform, the database and your recordings run on Google Cloud in Frankfurt, Germany, and the telephony infrastructure sits in a German data centre. Speech and language providers are used through their EU endpoints wherever the provider offers one. Where a provider processes outside the EU, that transfer runs on Standard Contractual Clauses, and every such provider is named with its processing region in our public Trust Center. An Article 28 data processing agreement applies from day one, with no separate negotiation, and we never use your data to train models.
Yes. Agents can detect a caller's language and respond accordingly, or you can configure language-specific flows per channel. This is particularly relevant for European businesses serving customers in German, French, Spanish, Dutch, and other languages alongside English, all within the same platform, without duplicating your entire agent setup.
No. The platform is designed for operators first. Flow building, agent configuration, channel setup, and integration connections are all no-code. Developers who want deeper control get a full REST API, webhooks, MCP-compatible tool discovery, and prompt-level customization, but none of it is required to run a production deployment. Non-technical teams operate Kilevel every day.
Completely. Every flow, agent behavior, escalation rule, and analysis signal is configurable, visually, without code. You define the tone, language, fallback responses, and handoff conditions. Advanced users can go further with prompt modules, templating parameters, flow templates, and a full REST API. If your workflow is unusual, Kilevel almost certainly supports it.
Complete control. You define tone, language, permitted topics, and response templates using prompt modules and templating parameters, reusable building blocks your agents draw from consistently. Escalation rules trigger human handoff based on sentiment, topic, or conversation outcome. Every configuration is fully testable in a sandbox before it touches a real customer.
You have full control over what your agent says. Define tone, language, and exact response templates. Escalation rules let you specify when a conversation gets transferred to a human, based on topic, negative sentiment, or repeated failed attempts. Everything is testable before it goes live, and you can iterate on agent behavior at any time.
Yes, and often without any setup at all. Kilevel supports MCP (Model Context Protocol), which means it can automatically discover and digest integrations from modern CRMs, ERPs, and data platforms. For everything else, there are webhooks, a REST API, and pre-built connectors. Your data flows in and out on your terms.
Both directions are fully supported. Kilevel uses MCP (Model Context Protocol) to automatically discover and integrate modern CRM and ERP systems, often with zero connector setup. In the other direction, Kilevel's REST API lets your own tech stack trigger calls, campaigns, and automations externally, and pull conversation results, analysis, and outcomes back into your systems on demand.
Yes, automatically. Kilevel scales concurrent lines dynamically, whether you're handling 10 conversations or 10,000, the infrastructure adjusts without manual intervention. The Operations Control Center gives you live visibility into concurrency, queue depth, and agent performance, so you're never operating blind at scale.
Your data sits in Frankfurt, Germany: platform, database and recordings on Google Cloud, telephony in a German data centre. Credentials are encrypted at the column level with AES-256-GCM, every query is scoped to its owning account, sub-users carry project-specific roles, and administrative actions are written to a reviewable audit trail. We process only on your documented instructions and never train models on your data. The full subprocessor list, with the processing region of each, is published in our Trust Center.
Kilevel agents are designed to manage uncertainty without frustrating the caller. They can ask clarifying questions, offer alternate paths, or escalate to a live operator, automatically, based on rules you set. The Attention Suite enables immediate human takeover mid-conversation without any disruption to the customer experience.
Kilevel agents handle uncertainty without derailing the experience. They can ask clarifying questions, reroute the conversation along alternate paths, or escalate to a live operator, all automatically, based on configurable rules. The Attention Suite lets operators intervene instantly mid-call, taking over the conversation without the customer noticing any disruption.