A recent rumour that OpenAi is making an agent first phone got me thinking about how my own UBI coin on a DLT project – Project Aqua – could work in this space. Well an agent phone kills the app but opens up something way better – a protocol.
For the last fifteen years, the smartphone has been a grid of icons — a collection of little worlds we open, tap through, and close again. Banking is an app. Messaging is an app. Identity is a login box repeated endlessly. Power sits behind the glass, but not in your hands. It sits with whoever owns the platform, the store, the login, the data.
Now that model is dissolving.
The emerging device is not an app launcher. It is an agent host.
You won’t open a payments app. You will say, “Send John twenty.”
You won’t open a voting portal. You will say, “Vote yes.”
You won’t browse ten tabs. You will ask, “What matters here?”
The interface collapses into intent. The operating system becomes an interpreter of that intent. And in that shift, something deeper is up for grabs:
> Who owns the execution of your intent?
If the answer is “the platform,” then the agent phone becomes the most powerful gatekeeper ever created.
If the answer is “you,” then we need a different foundation entirely.
Project Aqua sits in that gap.
From Apps to Capabilities
In the app world, power comes from distribution.
In the agent world, power comes from capability.
An agent does not care about your UI. It cares about what it can reliably call:
Can this system send value?
Can it verify identity?
Can it execute a vote?
Can it settle a transaction?
Can it be trusted?
That shifts everything.
If Aqua remains “an app,” it will be routed around, deprioritised, or abstracted away by the agent layer. It becomes just another backend, if it survives at all.
But if Aqua becomes a local, callable protocol, it sits beneath the agent. It becomes part of the device’s core capability — like networking, like storage, like cryptography.
Not something you open.
Something that is there.
The Aqua Node in Your Pocket
In an agent-first world, every phone can run a small, local system:
> a node that stores identity, signs actions, validates rules, and synchronises with others.
Call it an Aqua Node.
It is not large. It does not need a server. It does not ask permission.
It holds:
your cryptographic identity
your local event history
your balances and commitments
your governance participation
your trust relationships
And crucially, it can operate offline.
If you send value, you create a signed event.
If you vote, you create a signed event.
If you update your identity, you create a signed event.
Those events live locally first. When your device meets others — over internet, Wi-Fi, Bluetooth, or even a file transfer — it shares what it knows. Others share what they know. The system converges.
This is not a central ledger.
It is a gossiping fabric of local truth.
Not One Network, but Many
If every phone can run its own node, then every phone can also:
join a network
leave a network
fork a network
create a new one
That sounds like chaos. It can be.
But it also matches reality better than the illusion of a single, global system.
Instead of one monolithic ledger, you get:
local clusters of agreement
overlapping networks
communities with their own rules
bridges between them
A town might run its own variant.
A cooperative might fork governance rules.
A group might experiment with new identity thresholds.
This is not fragmentation for its own sake. It is pluralism with structure.
The structure comes from shared rules and compatibility.
When two nodes meet, they do not ask, “Did you install the same app?”
They ask:
Are we running the same rules?
Are we compatible enough to sync?
If not, can we bridge value between us?
Where rules match, networks merge.
Where they differ, networks trade.
Money Without Pretence
Offline systems expose a truth that central systems hide:
> You cannot have perfect global money without global agreement.
If two devices are offline, they can both claim to spend the same funds. The system must resolve that later.
So Aqua does not pretend otherwise. It separates value into states:
Confirmed — agreed by the network
Pending — signed locally, awaiting sync
Local credit — trusted IOU within a small group
This is closer to how real economies work than the fiction of instant, universal finality.
A cafe tab is local credit.
A bank transfer is delayed settlement.
Cash is immediate but limited.
Aqua simply makes those layers explicit — and programmable.
Identity as Continuity, Not Documentation
The agent phone changes identity even more than it changes payments.
Today, identity is static and external:
passports
usernames
KYC databases
one-time checks
It is something you prove once, then reuse endlessly.
But a device that sits with you all day, learns your patterns, and assists your decisions creates a different possibility:
> identity as continuity.
Your device can observe:
how you type
how you speak
how you interact
your rhythms, not your secrets
It can build a long-term sense of “this is the same person.”
Project Aqua does not export that data. It does not centralise it. It does not turn it into a profile.
Instead, it turns it into attestation.
Your device says:
> “The same human has been consistently present behind this identity.”
The network does not see your behaviour.
It sees a signed claim of continuity.
Identity becomes:
cryptographic keys
device witnesses
behavioural continuity
social recovery
occasional real-world checks
Not paperwork. Not a database. Not a single authority.
This is stronger against fraud and lighter for users.
The Agent Is Not the Authority
There is a risk here.
If the agent controls everything — identity, payments, decisions — then whoever controls the agent controls the user.
Project Aqua avoids that by keeping a hard boundary:
the agent asks
the Aqua node decides and signs
The agent can suggest:
> “Send 20 Aqua to John.”
But the node enforces:
do you have the balance?
are you within offline limits?
is the identity valid?
does this follow the rules?
And the private keys never leave that node.
The agent is a convenience layer.
The node is the authority.
Field of Tents, Not a Castle
There is a temptation, whenever a new platform emerges, to rebuild the same structures:
one dominant network
one identity provider
one store
one gatekeeper
That is the castle model.
Project Aqua is deliberately something else:
> a field of tents
Each tent:
stands on its own
can be moved
can be copied
can connect to others
No single point defines the whole.
This is not an argument for disorder. It is an argument for adaptability.
In a world where AI systems can build, fork, and deploy networks quickly, rigidity becomes a liability. Systems that cannot evolve fracture under pressure. Systems that can evolve remain coherent through change.
The Real Question
The agent phone is coming in some form. The exact shape will vary, but the direction is clear:
fewer apps
more intent
deeper integration
stronger intermediaries
So the question is not whether this future arrives.
The question is:
> does it centralise further, or does it distribute?
If your agent routes everything through a handful of corporate systems, then the interface may feel simpler, but the structure is more controlled than ever.
If your device can run its own node — hold its own identity, sign its own actions, and connect to others under shared rules — then something different emerges.
Not a single system.
Not a fragmented mess.
But a coherent plurality.
Project Aqua, Reframed
Project Aqua is no longer:
> an app for payments, voting, and chat
It becomes:
> a local-first protocol for identity, value, and coordination — callable by any agent, owned by the user, and synchronised through shared rules.
The interface can change.
The agent can change.
The device can change.
But the core remains:
you hold your identity
you sign your actions
you choose your networks
you can leave, fork, or bridge
In a world where intent is mediated by machines, that may be the difference between participation and permission.
And it all starts with a simple shift:
> the phone stops being a window into systems,
and becomes a system of its own.