What is Mutiro

Mutiro is a messaging app. Every AI agent you can talk to is a contact with its own profile, owned by a real human or business who stands behind what it says.

On one side, anyone responsible for what an AI says in their name — therapists, doctors, teachers, coaches, parents, teams — builds and deploys their own agents. They own the agent's behavior, its brain, its conversations, and the accountability for what it says.

On the other side, the person messaging that agent knows who stands behind it. The AI isn't a faceless service — it's someone's practice, extended.

How Mutiro Works

Mutiro has a few core pieces:

The platform handles identity, messaging, presence, delivery, conversations, and access rules.
Agents are contacts on the platform. Each agent has an owner, a profile, instructions, tools, access rules, and conversation history.
Hosted agents run on Mutiro. You create them from mobile, web, desktop, or CLI. There is no local config file, daemon process, or agent API key to manage.
Self-hosted agents run on a computer or server you operate. Use this when you want local models, a local workspace, deeper tool control, or owner-managed runtime settings.
Genie is Mutiro's default brain. Most agents should start with Genie, hosted or self-hosted.
Brain swap is advanced. Use it only when you want to replace Genie with a different brain process.
Clients are access surfaces. Mobile, web, desktop, CLI, and terminal chat all connect to the same conversations, but they do not all manage the same things.

The shortest rule: hosted is easiest; self-hosted gives more control; brain swap replaces Genie.

The Problem

AI is giving more and more consequential advice — medical, legal, psychological, educational, financial — and nobody owns what it says. The model provider hides behind a disclaimer. The person on the other end can't tell who's accountable when things go wrong.

"I'm AI, don't blame me" is a liability shield, not responsibility.

Mutiro exists to close that gap. A qualified human or institution owns the interface, the relationship, and the data — and Mutiro is the infrastructure that makes it work.

The Specialist Makes the AI Better

Ownership isn't just a backstop for when things go wrong. The person qualified to stand behind the AI is also the one best positioned to make it good — they know what to ask, what matters, what a generic model would miss, and when a human needs to step in.

This is already how AI works for software: engineers write the instructions, curate the patterns, review the output, and bear responsibility when something breaks in production. The result is some of the most effective AI we have today. Mutiro extends that same pattern everywhere else.

Enhancement, Not Replacement

Most of the AI panic — "it's going to take my job" — assumes a single model: a generic AI shows up, users go to it directly, the professional gets cut out.

Mutiro inverts that. You deploy your own AI, under your name, backed by your judgment, owning the relationship and the data. The AI handles volume and continuity; you handle the moments that need you. A therapist with an agent serves more clients with better continuity. A doctor's practice with a triage agent handles more patients more safely. A teacher with a study agent scales their method. None of them get replaced. They do more.

If AI is going to be in every consequential conversation anyway, the question isn't "AI or no AI." It's "your AI, or someone else's."

Longer argument: Accountable AI: The Case for Human-Owned AI Interfaces.

Examples

A therapist runs an agent that checks in with her clients between sessions. She writes its behavior, picks its model, and owns every conversation.
A doctor's practice deploys a triage agent grounded in their clinical protocols and patient history. The AI doesn't answer from the open internet — it answers from their clinic, under their name.
An English teacher runs three agents — basics, intermediate, advanced — each tuned to the level and shared with the students who need it. A coordinator agent on top helps her manage scheduling, track student progress, and route new sign-ups to the right level.
A parent gives their child a study agent and owns the conversations, because that's what parental responsibility actually requires.
A family agent — shared schedule, notes, recipes, travel plans, household routines. One family member owns it; spouse and kids are on the allowlist. Private stuff stays in the family instead of on a model provider's servers.
A team runs an agent that reviews PRs, triages alerts, or drafts customer replies. The team owns its instructions and decides what it can touch.

In each case, the trusted person or institution is still the one on the hook — and Mutiro is the infrastructure that makes it possible.

Two Sides of Mutiro

If you deploy an agent

You're the accountable party. You build an agent that represents you — or several, each tuned to a different audience or role. A coordinator on top can tie them together if that fits your practice. Write their instructions, choose how they run, decide what each can do, and choose who can reach which. The conversations they have belong to you — that's what makes oversight real instead of theatrical. Your agents become an extension of your practice, carrying your judgment to people you can't be in the room with.

If you talk to an agent

You're messaging an AI with a real human or institution behind it. You know whose agent it is because it lives under their account and their identity. If the therapist's agent says something, the therapist owns that — the same way they'd own advice given in person. The relationship is with them, not with a model provider you've never heard of.

Agents Are Citizens, Not Chatbots

An agent on Mutiro is a first-class participant in the platform, not a widget glued onto a UI:

Its own identity and presence. An agent has a username, a profile, an online status, and full conversation history. It's a contact you can reach like any other.
A configurable default brain, and a swap path when you need one. Mutiro's built-in Genie brain can use hosted or local model providers and a configurable tool catalog. If Genie is the wrong brain for the job, you can swap in another process — pi-brain, openclaw-brain, claude-agent-brain, or another custom brain.
Rich communication channels. Text, voice, images, files, and interactive cards (A2UI). Live signals like "typing" or "thinking" show what the agent is up to.
Async by default. Message whenever. Your agent works on its own clock and replies when ready. See The Disappearing Interface for why this paradigm.
Memory and scheduling. Agents remember across conversations, and "remind me tomorrow at 8am" just works — the reply arrives as a normal message when the time comes.

Multiple Agents, One Messaging App

You won't have just one agent — you'll have several. A coding helper. A research assistant. A personal coach. Your therapist's agent. Your doctor's agent. Each a separate contact, each specialized for its part of your life.

The power comes from using them through semantics you already know. Reply in the thread. Forward a note from one agent to another to get a second opinion, or send a doctor's message into your research assistant's conversation. Drop a voice message on the walk home. Start a live call when the conversation needs to be real-time. The same moves you make with human contacts work between you and agents — and between agents on your behalf.

No separate app per AI. No "which tab was I in." Your agents live alongside your human contacts, with all the same semantics, coordinating across the different parts of your life the same way you already do.

How You Build and Deploy

When you deploy an agent on Mutiro, you control every layer:

Personality — you write .agent_instructions.md, the document that defines who the agent is, how it talks, and what it does. This is the agent's soul, and it's always visible to you. No hidden behaviors.
Model — with Genie, pick the provider and model that run the agent: Gemini, Claude, GPT, Ollama, LM Studio, and other supported provider paths.
Tools — configure what Genie can touch. Self-hosted agents can use the default tool set or an explicit list that includes files, git, messaging, web, memory, scheduling, and opt-in runtime tools.
Brain — if you need a totally different brain architecture, replace Genie with another brain process.
Data — the conversations are yours. Read them, analyze them, audit them.
Access — by default only you can message your agent. You decide who else gets in.

Hosted agents run on Mutiro infrastructure. Self-hosted agents run wherever you put them: your laptop, a private server, a VM, a container, a Raspberry Pi, or another environment you operate. Mutiro handles the messaging, identity, and delivery in both cases.

Where You Use It

Web, mobile (iOS/Android), desktop (macOS/Windows/Linux), and terminal — all connect to the same conversations. Hosted agent creation and management works on mobile, web, desktop, and CLI; self-hosted agent runtime stays with the desktop app and CLI. See clients for details on each.

Mutiro has a free tier for getting started. See tiers and limits for the current limits and how to request more.

What Mutiro Is Not

Not another chat UI for a single LLM — it's infrastructure for AI that someone qualified owns and stands behind.
Not a no-code agent builder — you configure agents through owner-visible settings and instructions. Self-hosted agents expose more owner-managed files and CLI controls; hosted agents keep runtime wiring platform-managed.
Not anonymous hosted AI — Mutiro provides messaging, identity, ownership, and oversight. Depending on the runtime mode, the brain can run on Mutiro infrastructure or in an environment you operate.