Not a chatbot.
A runtime for persistent AI agents.
Most AI agents answer a one-off request. Pumaï goes further: agents that live in the background, watch topics, run scheduled tasks, build their own tools, draw on long-term memory, call external services — and stay under human control.
A fictional small business. An assistant that truly works.
To test Pumaï under real conditions but with no real-client stakes, we handed the mailbox of an imaginary company — Nautilia Systems, a marine-electronics specialist (GPS beacons, telemetry, monitoring of boats and marinas) — to a fully autonomous assistant that runs around the clock, with no human intervention.
It reads and sorts every incoming email, qualifies quote requests and creates prospect records, tracks support tickets and escalates emergencies, watches competitors and online reputation, chases unpaid invoices with tact, and writes its management reports every day. Everything a sales assistant would do — continuously.
All under strict control: no email is ever sent to an unauthorized recipient, and any committing action (quote, sales reply, complaint) goes out as a draft awaiting approval. The assistant never promises a price, a deadline or a discount that isn't in the rules or data it was given.
a proof-of-work page fed in real time by the instance's actual activity — names and addresses are masked, and nothing is staged.
A reliable execution runtime for agents that act
Pumaï brings together, in one runtime, building blocks rarely assembled: autonomy, memory, tools, governance and observability. An agent can take a request, search its memory, pull context via RAG, explore relations via Graph RAG, pick tools, produce a plan, execute actions, ask for approval when needed, log what it does, then consolidate its experience. That complete loop is what most agentic frameworks are missing.
Partitioned, yet coordinated
Each profile keeps its private memory, tools and channels. Shared on purpose: a document cabinet and the company directory.
Multi-tier
Recent conversation, summarized segments, vector RAG, relational Graph RAG — consolidated nightly.
Orchestrator / experts
An orchestrator plans, ReAct expert agents execute in parallel waves with real tools.
Heartbeat & Pulz
Watch, trigger and pursue missions without waiting for a user prompt.
Tools on demand
Design, test, fix and version tools in a sandbox — plus MCP connectors.
Native, not an add-on
Human approval for sensitive actions, append-only audit log, quotas, partitioning — evaluated at every tool call.
the key difference: Pumaï isn't about "making an AI talk" — it's about giving agents that can act a reliable place to run.
The platform just leveled up
A wave of major additions makes Pumaï significantly more powerful: a knowledge graph, a tool-building studio, MCP connectors, a phone gateway (inbound/outbound calls), streaming responses with visible reasoning, an interface now in English, and more.
More than an assistant. A runtime that acts.
Classic assistants wait, forget, and stop at text. Pumaï addresses all three limitations at once.
| axis | classic assistant | pumaï |
|---|---|---|
| Trigger | Passive — waits for a prompt | Proactive — a background heartbeat, lives without human interaction |
| Memory | Amnesic — limited context window | Sedimentary — partitioned memory + nightly consolidation |
| Action | Simulates, or stops at text | Agentic — an orchestrator delegates to a team of expert agents with real tools |
| Governance | Uncontrollable black box | Glass box — conditional locking, human validation, append-only audit |
put another way: Pumaï is less an "AI assistant" than an operating system for AI agents.
The architecture, at a glance
A central API resolves the profile, assembles context, applies security and quota — then routes into three subsystems: memory, the agentic engine, and the autonomous background loop.
stack — Python 3.12 · FastAPI · PostgreSQL + pgvector · OpenAI-compatible client (model provider configurable) · Docker.
Your assistant, your rules, your data
Pumaï is deployed as an isolated instance: each client gets their own — their data, their mailbox, their keys, their configuration — isolated from other clients'. You stay in control end to end.
One instance per client
Your data is stored in a dedicated instance, isolated from other clients'. Any processing or transfer to external services (AI model, email, telephony…) depends on the providers and connectors you configure.
No vendor lock-in
Pumaï is tied to no AI provider: we pick the model that fits your requirements for quality, cost or confidentiality — and the system reasons in any language.
Your tools, your connectors
The list of capabilities isn't fixed: custom tools built in a sandbox, MCP connectors to your services (mail, calendar, databases…). We open a tool, the assistant uses it.
Never a black box
Every decision, every action and its cost is logged and consultable: append-only audit log, execution trace, per-instance quotas. An AI that acts on its own, yet always under your watch.
What just landed in Pumaï
Knowledge graph
Beyond vector RAG, memory now weaves a queryable graph of entities and relations — better-connected answers and an understanding that structures itself over time.
Tool-building Studio
Design, test and version your own tools through a guided, sandboxed assistant. The agent gains new capabilities, tailored to your needs.
MCP connectors
Plug in external MCP servers to extend the agent: add manually, search the npm registry, or import directly from a URL, package or JSON.
Redesigned Tools page
A reworked, far more practical interface, with a Lock Manager that finally makes approving and locking each tool simple.
Phone gateway
Through Twilio, your agent can now receive and place phone calls — a voice that answers, calls out and reports back.
Streaming responses
Messages appear progressively as the AI writes them — smooth on screen, essential for real-time voice.
Execution trace
Follow the agent's execution trace right in the chat — its steps and the rationale behind its decisions, not just the final answer.
More powerful logs
The log page becomes a real activity view: sessions, runs and events, to understand what the system is doing.
English interface
The interface is now translated into English (≈80%, the rest is on its way), opening Pumaï to a wider community.
Built-in support
A support button at the bottom of the interface sends a message that lands straight in our tracking tool.
Reusable Competences
Teach a know-how once — handling a quote, managing a complaint, opening a ticket — and the assistant then applies it identically. A dedicated studio builds them through a simple guided interview and measures the gain.
A real mailbox
The assistant reads, files, opens attachments, prepares drafts and actually sends its replies — but never to a recipient outside your allowlist, with the "draft awaiting approval" option.
The document cabinet
A shared central binder: you drop in your reference documents, the assistant files its output (reports, quotes, sent attachments). Everything is dated, traced, and its lifecycle tracked (draft → to send → sent).
Activity dashboard
Not a technical log but a narrative: goal → steps → result. Ongoing missions, the day's figures, time and cost saved — auditable and honest (a lookup is never presented as an action).
Showcase — proof of work
A page that shows, live, from the system's real log, everything the assistant accomplishes autonomously — honest figures, decisions, downloadable files. Private by default, publishable in one click, personal data masked.
Next step: contexts twice as light
The next big leap is already underway: representing context no longer as a long text to re-read, but as a knowledge graph seasoned with prompt fragments — a far more compact form that cuts 50 to 70% of the volume the assistant must load at each step, without losing the thread. The payoff: faster answers, a markedly lower cost per action, and a longer working memory at equal budget.
This is still research & development: the 50% compression mark is already reached in testing, with near-intact comprehension. The current work targets ~60% while keeping comprehension nearly intact. We advance, step by step.
prototype in testing — not yet in production.
One runtime, four capabilities
It converses
Multi-channel dialogue (web, API, Telegram, Discord, phone) with a memory that spans months.
memory & learning → 02 — actIt acts
It breaks complex requests into a team of expert agents using real tools.
the engine → 03 — operate autonomouslyIt operates autonomously
It runs continuously: watches, scheduled tasks, long-term missions — with no one at the controls.
autonomy & Pulsar → 04 — stay governableIt stays controllable
Native governance, evaluated at every tool call: human approval for sensitive actions, append-only audit log, quotas, partitioning.
governance →An AI that acts on its own must stay controllable
Pumaï doesn't promise a magical, uncontrollable AI: it offers infrastructure for governable agents. Every action can be traced. Every tool can be limited. Every profile can be isolated. Every sensitive decision can go through human approval. And all autonomy can be disabled instantly — with a single control.
Let's talk about your project
Have a specific use case to scope, or want to see Pumaï run on your business? Write to us — individual reply within 48h.
No mailing list — just a real conversation.