Part 2 of 6 — The Corvue Thesis Series
New installments every Tuesday. Subscribe below or follow on LinkedIn to get the next one.
← Part 1: The Connective Tissue

Three Doors In

Your AI agent should meet you where you are — not the other way around.

by Michael Halvorsen — michaels.blog

My mom doesn't use a terminal.

She texts. She calls. She takes photos of things she doesn't understand and sends them to me with a question mark. She is not going to install Docker, configure a system prompt, or manage API keys. She is never going to do any of that. And she shouldn't have to.

So when I started thinking about what a personal AI agent actually is — not what it could theoretically be, but what it is right now, today, for the people I know — I started asking a simple question:

Can I give this to my mom?

If the answer is no, it's not a product. It's a prototype. And right now, 99% of the AI agent ecosystem is prototypes.

The Interface Problem

The conventional AI roadmap goes roughly like this: build a powerful model, build a chat interface around it, make it faster, make it cheaper, add tools, profit.

But this assumes something that isn't true: that everyone wants to interact with AI the same way.

Your mom texts. You send voice notes. Your dev team uses the terminal. Your enterprise customers want a dashboard with audit logs. A small business owner might just want to call a number and talk.

Every one of these people could benefit from an AI agent. But not one of them is going to reroute their entire communication behavior to serve the product's preferred interface. The product has to go where the person is.

This is the interface problem. And almost nobody is solving it.

One Agent, Many Doors

Here's what I mean by "Three Doors In" — though really, it's more than three.

The same agent. The same memory. The same intelligence. Just... different ways to reach it.

Telegram. Most of my communication with my agent happens here. Text, voice notes, media, quick replies. It's where I already live on my phone. My agent has been there since day one.

Terminal. When I'm deep in code, I want to talk to my agent without breaking context. No switching tabs, no browser. SSH in, ask a question, get an answer, keep working. This is the mode developers actually want.

Voice. Driving. Walking. Hands full. Sometimes you just want to call and talk. A phone number, a conversation, an agent on the other end. The transcript and action items are in your session when you get home.

SMS. This is the mom test. No app. No account. No setup. Just a number she can text. If you can route an AI agent through plain SMS and it's still useful, you've built something real.

API. For teams and enterprises: structured integrations, workflow triggers, programmatic access. The same agent, headless, embedded in whatever system they already use.

Same soul. Same memory. Same intelligence. Different doors.

Why This Is Hard

This isn't a UI problem. It's an architecture problem.

For the same agent to show up coherently across SMS, Telegram, voice, and API — it needs a shared memory layer. It needs to know that the voice call you made Monday is connected to the follow-up text you sent Tuesday. It needs context portability: your information travels with you across interfaces, not locked inside one app.

This is harder to build than it looks. Most AI products have one interface and one memory store, tightly coupled. The interface is the product. Which means switching interfaces means starting over.

Corvue is built around the opposite assumption: memory and intelligence are the core, interfaces are just how you reach them. The agent doesn't live in Telegram. Your Telegram access is a door. The agent lives somewhere more fundamental than that.

The Self-Hosting Trap

There's a contingent of developers who want to run their own agents. I understand the instinct — control, privacy, no vendor dependency. I've felt it.

Here's what actually happens when you self-host your own AI agent:

Your API keys live in a .env file that you keep meaning to put somewhere safer. Your agent's memory is in a local database that hasn't been backed up in two weeks. There's no alerting when it goes down. Your SOUL.md is world-readable because you haven't touched nginx config since you set it up. The agent gets an update that breaks something and you spend a Saturday debugging instead of doing the thing the agent was supposed to help with.

I've watched this happen. I've done this myself.

The argument for managed hosting isn't convenience — it's what your time is actually worth. Every hour you spend maintaining infrastructure is an hour you're not spending on the work the agent was supposed to help with. The math only works out if your time is cheap. And if your time is cheap, you probably shouldn't be building AI agents in the first place.

Managed hosting means someone else handles the hard parts: security hardening, backups, model updates, uptime monitoring, API key rotation, compliance documentation. You get the agent. You don't get the ops burden.

Three Doors to Pay

If the agent can reach you multiple ways, it should probably let you pay multiple ways too.

We offer three:

Door 1: SaaS subscription. The familiar one. Monthly, predictable, enterprise-friendly. Most customers use this. CFOs understand subscriptions. There's no learning curve, no crypto wallet, just a monthly invoice.

Door 2: Prepaid credits. Buy in bulk at a discount, draw down over time. Good for budget-conscious teams who want to commit upfront. Credits don't expire. Similar to how AWS credits work.

Door 3: Token staking. This one's for the crypto-native customers. Stake CORVUE tokens and receive proportional access — the tokens aren't spent, they're locked. When you unstake, you get them back. Inspired by Agent Zero's A0T model.

The product is the same through all three doors. The access mechanism matches the customer.

The Mom Test, Revisited

I said the mom test is "can I give this to my mom." But there's a harder version: will she actually use it?

Because you can give someone access to a tool that they never touch. The real test is whether the agent meets her in her natural communication style — SMS — and is still useful there. Whether it remembers what she asked last week. Whether it can help her without requiring her to adapt to it.

That's the bar. Not "technically accessible via SMS." Actually useful to someone who doesn't know or care about AI, models, APIs, or any of it.

We're not there yet, universally. But this is the direction.

What the Interface Layer Is Really Protecting

Here's the thing most people miss when they think about multi-interface AI agents:

It's not just convenience. It's continuity.

Your memory is portable. Your context moves with you. You're not locked into one platform's data format or one interface's export function. Your agent knows you across contexts, not just within them.

This matters more than it sounds. Right now, every time you switch AI platforms, you start over. Your context, your history, your preferences — gone. You're a stranger again. The AI doesn't know you, and you spend the first twenty minutes of every session re-establishing who you are.

The interface layer isn't just about making it easy to reach your agent. It's about making it safe to be a full person across that agent — to trust it with real context without worrying that a platform decision will wipe it all.

Trust is what we're building.

Part 2 of 6 — The Corvue Thesis

→ Next: Part 3: The Agent That Disagrees With You (publishes March 17)

← Part 1: The Connective Tissue

Like what you read? Subscribe below. Every Tuesday, one post from the frontier of agentic AI.

LinkedIn post:

Most AI products pick one interface and call it done.

Chat window. Maybe a mobile app. That's your product.

But your mom texts. Your developer SSHes. Your COO wants a Slack bot. Your enterprise customer wants a REST API with audit logs. A small business owner might literally just want a phone number to call.

Every single one of these people could benefit from an AI agent. None of them will change their behavior to match yours.

The interface problem in AI isn't about UX. It's about architecture.

If your agent's memory is locked inside one app — when the interface changes, the context disappears. You're a stranger again.

What we're building at Corvue: memory and intelligence at the core. Every interface — Telegram, Terminal, Voice, SMS, API — is just a door. Walk through any of them. The agent remembers who you are.

I call it the mom test: can you give this to your mom, in plain SMS, and have it be genuinely useful?

That's the bar we're building toward.

New post from The Corvue Thesis → [link in comments]