Every AI task app is building the same thing: a chatbot inside the app.
A little text field in the corner. A sidebar that opens. An assistant that knows your tasks but nothing else about your life. You type a message, it responds, and the conversation lives inside the task app’s walled garden.
Ember doesn’t have a chatbot. That’s not a missing feature. It’s the whole point.
The built-in chatbot problem
When a task app ships its own AI assistant, it starts from zero. It doesn’t know your files. It doesn’t have your browser history for research. It can’t access your code editor, your documents, your email. It has exactly one capability: talking about your tasks.
So you get an assistant that can rephrase your task titles, generate subtasks you didn’t ask for, and summarize things that were already short enough. It’s AI theater — visible, but not useful in the ways that matter.
Meanwhile, the agent you actually use — Claude, or whatever tool you’ve set up — already has the context. It has your workspace. Your tools. Your files. Your conversation history. Your preferences built up over weeks or months of use. It knows how you think because you’ve been thinking with it.
Why would you abandon that for a chatbot that starts from scratch every time?
What “bring your own agent” actually means
Ember connects to any agent that speaks the Model Context Protocol. When you set up the connection, your agent gets access to your task list — the ability to read tasks, create them, complete them, organize them, and see what you’ve delegated.
That’s it. Ember provides the task data. Your agent provides everything else.
When you delegate a task and sit down with your agent, the conversation happens in your agent’s environment. Not in a cramped sidebar. Not in a modal window inside a task app. In the full-powered tool you already use, with access to everything it already has.
Your agent can research things on the web. It can read your documents. It can write files. It can use whatever tools and integrations you’ve already configured. The delegated task is the starting point, but the work happens with your agent’s full capabilities — not a stripped-down assistant limited to task operations.
Your agent already knows you
This is the part that matters most.
A built-in chatbot doesn’t know that you prefer bullet points over paragraphs. It doesn’t know your budget constraints, your timezone habits, your communication style. Every interaction starts cold.
Your agent has been learning. Not in a creepy data-harvesting way — in the normal way that tools get better when you use them. Your conversation history, your preferences, the way you phrase things, the follow-up questions you tend to ask. All of that context makes the agent more useful every time you talk to it.
When you delegate “Research birthday venues” and your agent already knows you live in Austin, that your budget tends to be practical, and that you prefer options presented as a comparison table — it doesn’t need to ask all of those questions. It starts further ahead because it already knows you.
A built-in chatbot would ask you all of that every time. Your agent skips the basics and gets to the work.
The system constrains the agent
“Bring your own agent” might sound like a free-for-all. It’s not.
When your agent connects to Ember, it receives a delegation protocol — a set of rules baked into the system that tell it how to behave. These aren’t suggestions. They’re constraints.
The agent must check delegated tasks first. It must use your Now/Next placement as a priority signal. It must ask clarifying questions before acting. It must present options and let you decide. It cannot auto-complete tasks or reorganize your lists without your say-so.
Your agent brings its capabilities. Ember provides the structure. The agent works within that structure, not around it. This is why delegation feels safe — you’re not giving an AI free rein over your task list. You’re giving a capable agent specific assignments with clear boundaries.
Two tools, one workflow
The split is clean. Ember captures your intent during your normal task review. Your agent acts on that intent during your normal agent conversation. Neither one tries to be the other.
Ember doesn’t try to be a chat interface. Your agent doesn’t try to be a task app. Each does what it’s good at, and the Model Context Protocol is the bridge between them.
This means Ember’s AI story ages well. When agents get better — more capable, more context-aware, better at research — your delegation workflow gets better automatically. You don’t need Ember to ship an update. You don’t need to wait for a new AI feature inside the app. You upgrade your agent, and the tasks you delegate benefit immediately.
The app stays simple. The agent gets smarter. And the connection between them is an open protocol, not a proprietary integration.
Not locked in
Today you might use Claude. Next year you might use something else. Or you might use different agents for different parts of your life — one for work research, one for personal planning, one for creative projects.
Ember doesn’t care which agent you connect. The protocol is the same. Your task data is yours. Switch agents whenever you want, and your delegation workflow carries over.
This is the opposite of what happens when a task app builds its own AI. You’re locked into their model, their capabilities, their update schedule. If a better model comes out, you wait for the task app to integrate it. If you want to use a different AI for different tasks, you can’t.
Bring your own agent means you’re never locked in. The best agent for the job is whatever agent you choose.