X-Zero · Personal · In development

It remembers. That is the whole idea.

Every assistant you have used starts over. You restate the context, it produces something reasonable, and the session closes and takes the understanding with it. X-Zero is bound to one person instead of one conversation: what you decided, what you rejected, and why — kept, so the useful answer is the one that accounts for the last three. It reaches the same engine as our enterprise products, which means it can act, and everything it does leaves a record before it happens.

ARE5 Technologies
01

Why the horizon changes everything

Not a longer context window. A different relationship with time.

MEMORY

It accumulates rather than resets

Preferences, facts, the shape of how you work, and the decisions you already made. A new conversation continues instead of starting from the same blank page you filled in last week.

REFUSALS

It keeps what you said no to

An answer you rejected is information, and most systems throw it away. Holding the rejections is what stops an agent proposing the same wrong thing for the third time.

VOICE

Speaking is not a separate mode

Voice reaches the same tools, the same memory and the same control layer as text, so an instruction given out loud is governed exactly like one that was typed.

02

What it inherits, and what it adds

A fourth product is a configuration, not a rewrite. This is the part that is already running before X-Zero starts.

Agent graph
Routing, extraction, conversation and tool execution — the same nodes the enterprise products run on, with a model chosen per step.
Long-term memory
Preferences, facts, summaries and episodes that persist across sessions, isolated per person.
Control layer
Deterministic code decides what an agent may do, writes the intent before the action, and keeps the record immutable.
Voice channel
Speech to speech without a transcript step in the middle, on the same tools as text.
Its own interface
Twenty-seven screens on a settled architecture, with the test suite green — the part specific to one person rather than a company.
Its own knowledge
What accumulates belongs to its owner. No shared model is trained on it.
03

Where it stands

X-Zero is in development. Here is what that means concretely, because "coming soon" tells you nothing.

BUILT

The interface is finished

Twenty-seven screens on an architecture that has settled, with the test suite green. This is usually the part that drags; here it is behind us.

BUILT

The engine is already deployed

The graph, the memory, the control layer and the voice channel run in production for our other products. X-Zero does not need them built, it needs to be connected to them.

IN PROGRESS

Deciding what genuinely needs a server

Most of its surfaces can read from the engine directly; a few need something of their own. That decision comes before the code, which is why it is the current work.

NO DATE

Next in line after AIO

We are not naming a month. The product with paying users comes first, and saying that plainly costs us less than a date we would later have to explain.

04

Interested early

If an agent that remembers your last two years sounds more useful than one that writes well, that is the conversation we want.

05

Questions about X-Zero

Asked before anyone decides whether this is for them.

How is this different from an assistant I already have?
The horizon. A session-bound assistant starts over each time and asks you to restate context you already gave it. X-Zero is built to keep what you decided, what you rejected and why, so the answer accounts for the last three conversations rather than only the current one.
Who owns the memory?
The person it belongs to. Memory is isolated per user, no shared or general-purpose model is trained on it, and what accumulates is a dataset that stays with its owner rather than becoming training signal for someone else's system.
Why does a personal agent need a control layer?
Because it acts. The moment an agent can spend money, send something on your behalf or delete something you cannot recover, the question stops being how well it writes. It runs under the same deterministic layer our enterprise products answer to: the intent is recorded before the action, and a refusal is as traceable as an approval.
What is actually built, and what is left?
The interface is finished — twenty-seven screens on a settled architecture with the test suite green — and the engine behind it is already deployed and running our other products. What remains is deciding which of its surfaces genuinely need a server and connecting those to the graph, memory and control layer, rather than building any of the four again.
When does it launch?
No date. It is next in line after AIO, and naming a month we could not defend would cost more than saying this plainly.