Write once. Run any channel.
Voice. WhatsApp. Chat. Mobile. Email. API.
One agent. One runtime. One governance layer.
The same agent serves every channel. Written once, it runs on voice, WhatsApp, in-app chat, email and the API, with the same rules and the same audit trail. Underneath, the Agent Kernel handles scale, isolation, recovery, policy and cost, and the company keeps what matters: the business, the policy and the customer.
An Agent Kernel under every agent.
The first agent ships in weeks. Running it for millions of customers, under regulation, for years, is a different project. Tessera solves that once, in the Agent Kernel, and the business keeps what matters: the business itself, the policy and the customer.
Real-time voice
Real-time voice puts the same agent on the phone, with the same rules, audit trail and cost cap as on WhatsApp and chat. It listens, thinks and answers like a normal conversation, stops talking when the customer interrupts, and a person can listen in, coach the agent or take over the call.
First-class voice
The phone is a full channel, with the same rules, audit trail and cost cap as every other channel.
Real time, low latency
Answers at the pace of a conversation and stops talking when the customer interrupts.
Massive parallel execution
Many calls at once, each with its own agent, all of them supervised.
Automated contact center
The featured case: end-to-end service, with a person ready to take over the call.
Mission Control
Mission Control is where you build and ship agents. You draw the flow or write it in Matiq, and it's the same agent either way. Human approvals and business rules are steps in the flow, and nothing goes live without passing the compiler.
Operational self-learning
Self-learning makes agents improve from their own operations. Every interaction becomes training data, the business defines what a good outcome is, and the system adjusts how the agent behaves. Every change is tested first with simulated customers and a small share of real cases, and rolls back on its own if results get worse.
Know Your Agent
Know Your Agent is each agent's record. It answers what risk and compliance need to know: who it is, what it accesses, when it asks a person for help, what limits it has, how it records its decisions and how it gets shut down. If the record isn't in order, the agent doesn't go to production.
Build, improve, talk and trust, all on the same kernel.
Flow, code and tests in one artifact, with approval as a node.
Reinforcement learned from the operation, with no ML pipeline.
The phone reaches the same agent, with the same rules and trail.
Record, limits and trail for every agent, checked before go-live.
Five things no one else in the category has, four delivered, one earned
Why it matters: The regulated half of the agent market won't deploy what it can't audit. These five are what an audit demands, and each one had to be born in the engine, not in a library.
Every competitor ships an SDK or YAML. Matiq is a language: a pack is verified by a compiler and ships ready.
Verify every pack with a compiler, not a manual review.
Get the pack ready to run, not an SDK to assemble.
Deterministic execution on a clustered actor runtime. Everyone resumes; only we resume identically.
Resume a run from where it stopped, with the same context.
Replay the same decision, identically, on any node in the cluster.
Four-eyes approval, a kill switch and tamper-proof audit, inside your own cloud, with no vendor control plane in the path.
Approve critical actions with four eyes, before they run.
Stop any agent with the kill switch, instantly.
Business rules as a platform primitive, authored from compliance's spreadsheet, with one legal citation per rule.
Start from the spreadsheet compliance already keeps.
Cite the legal basis of every rule, one by one.
The founder spent sixteen years delivering critical systems to Brazil's largest banks and insurers.
Built by the people who built the systems it governs.
Count on a team that knows your legacy stack and how your institution actually buys.
What actually happens to an agent on the AgentOS.
Tessera runs, describes, governs and connects agents with components of its own. Each one handles part of the work, and all of them report to the same Control Plane.
Written in a language, checked by a compiler
A collections agent in fifteen lines of Matiq. The compiler checks types before deployment: a broken contract fails at compile time, before a single token is spent.
Run as an actor, scaled as a cluster
Every conversation is an isolated, supervised, event-sourced entity, with a checkpoint at every step. A thousand children on the clock of the slowest one. A three-day wait survives a node going down.
Governed before the call, not after
Four-eyes approval on sensitive actions, spending caps, a kill switch per tenant, and a console that shows which policies are provably enforced.
Proven, decision by decision
The rule that fired with its legal citation, the prompt version, the cost, tamper-evident per tenant. Exact replay of the run months later.
Debugged like a program, in production
A breakpoint on a live run, an operator pause across the whole cluster, time travel to any checkpoint and a fork from there.
Connected to what the company already runs
Frameworks, models, tools and enterprise systems, governed where they are. Open tool protocols in both directions, voice with barge-in, WhatsApp, Kafka and email, with the same guardrails and the same audit trail.
Write once. Run any channel.
The same agent runs voice, chat, WhatsApp and email on the same runtime, with identity, governance and audit trail. No migration and no rewrite.
Built for the enterprise stack
Each brand below is a system Tessera connects to and governs where it already runs. The mention is of technical compatibility: your teams keep what they chose.
Operations that can't fail are where agents help most.
The journeys change from one industry to the next. The kernel and the governance don't.
Built by the people who built the systems it governs.
Felipe Scaphe founded Sciensa in 2010 and Tessera in 2026. The product and engineering core comes from Sciensa: sixteen years delivering mission-critical systems to banks and insurers, now building the platform that governs their agents. Sciensa is the team's track record, not a Tessera shareholder.
Massive parallelism, built for fleets.
A conversation is an actor. A fleet is a cluster: entities spread across nodes on their own, and supervision, backpressure, passivation and rebalancing are properties of the runtime, not code written for each journey.
Governance, execution and cost in one place, for every agent.
What runs today keeps running as the fleet grows.
Every new agent arrives with an owner, a version and a policy.
And when you need to build, build faster.
Create agents directly inside Tessera and go from development to governed production without assembling yet another infrastructure stack.
Visual workflows
Build the agent's flow on a canvas and follow the run in the same place.
Reusable components
Nodes, tools and policies shared across agents and across teams.
Integrated tools and models
Connect models and enterprise systems without writing the integration layer.
Built-in governance
Agents start inside the organization's policies instead of being retrofitted later.
Production-ready deployment
Promote revisions across environments with pre-flight checks, approval and rollback.
Native observability
Runs, costs and decisions visible from the very first run, with no instrumentation.
Your agents need an operating system.
The first agent ships in weeks. An Agent Kernel runs every one that comes after it: at massive scale, in regulated environments, with governance at the center, proven decision by decision.