Echo App

Our digital tools each hold one part of our lives: conversations in messaging, decisions in email, appointments in the calendar, ideas in notes. Every time we switch interfaces, some context disappears, and users have to rebuild the links between people, information, and actions themselves.

Adding a chatbot on top of this stack solves nothing. Without a shared architecture, either the context has to be repeated for every request, or the chatbot must be given indiscriminate access to all data and tools, creating more noise, cost, and risk of error. The problem is not adding AI, but giving it the right place in the system.

I designed Echo as a systems architecture rather than as an application to which a model had been added. Conversation becomes a shared control surface; behind it, a router distinguishes a response, a command, a search, a memory, or a complex task.

Each request takes the simplest route capable of resolving it. Code handles what must remain deterministic, tools are authoritative for their own data, memory provides only the useful context, and models intervene for novel situations. AgentCore orchestrates these components and distributes the work among rules, small models, powerful models, and specialized agents, without making Echo dependent on a single provider.

The result then returns to the system: a success can shorten a route, a failure can become an experience, and a correction can alter a weight or a memory. Intelligence is not concentrated in a chatbot; it emerges from the way the organs cooperate and learn over time.

Echo does not rely on a single intelligence to which everything is sent. Depending on what happens, the system can use a known reflex, a specialized rule, memory, a tool, an agent, or a language model. I built this architecture so that each problem follows the simplest path capable of solving it, and so that the result can improve future decisions.

The features presented below are not animations replaying a prepared scenario. They are interactive representations of the mechanisms that connect conversation, tools, and learning.

The next step is less about adding features than about stabilizing Echo until I can truly live in it every day. Several tools still need to be finished or consolidated, especially the ones that allow the assistant to act on the environment rather than simply talk about it. I want to keep improving the brain, memory, voice, and automations, but above all to make all these blocks converge into an application reliable enough to gradually replace part of the software I use today.

At first, I imagined Echo almost entirely around Mistral. With use, that constraint no longer makes much sense. Models do not have the same qualities, costs, or specialties. Some are better at dialogue, others at reasoning, coding, extracting structure, or processing an image. Echo has therefore deliberately become provider-agnostic. OpenRouter completes this logic by giving access to several model families behind a common interface, so the architecture can choose the right engine instead of asking the same model to do everything.

In the long term, I would like to make it an open-source, truly autonomous application to install: you deploy Echo, enter your own API keys, choose your providers, and the system works without depending on my infrastructure or a mandatory subscription. The economic point matters too: anything that can be solved locally, algorithmically, or learned from use should gradually stop triggering a paid call. The model becomes an interchangeable resource, not the product itself.

And one much more important evolution probably remains: connecting Echo to real work agents like Claude Code or Codex. The assistant could then go beyond the tools explicitly planned by the application: read and modify code, build a missing tool, investigate a failure, run a search, test its result, then try again. Echo would no longer be only the place where my tools and my assistant share the same context. It could become the environment from which an intelligence actually helps build that environment. This is probably where the idea of a personal operating system begins to make full sense.