One assistant, many bodies

At seven, halfway through a bike ride, you tell the band on your wrist to move the dentist to next week. At nine the card on your lanyard reminds you of a meeting, but not that you meant to raise the budget in it, because you said that to the speaker in the kitchen. At eight in the evening you open the pocket deck to write the email you have been putting off all day, and it has no idea what the day was. Three devices, three assistants, and you are the only thing connecting them.

That is the normal state of things. Each device arrives with its own assistant, its own account and its own memory, and you either repeat yourself across them or give up and use only one.

The real cause: the assistant belongs to the product, not to you

Assistants are built per device because they are sold per device. Identity lives in the vendor’s account, memory lives in the vendor’s cloud, and the only bridge between your watch and your laptop is a server you do not own. When two of your devices come from different makers, there is no bridge at all.

The deeper mistake is treating the body as the identity. A body decides what an assistant can sense and do: a microphone, a screen, a keyboard, wheels. It should not decide who the assistant is, what it remembers or whose side it is on.

How it goes wrong

Several assistants, several memories. Every device knows a slice of you. None of them knows the day. The more devices you own, the less any one of them understands.

The cloud as the only glue. To get a note from your wrist to your pocket, it travels through a vendor’s data centre. Sync becomes the reason your memory leaves home.

Designed for the phone, squeezed onto everything else. The assistant on the wrist is the phone assistant with a smaller screen. It does not know that your hands are busy, that a glance is all you have, or that a short vibration says more than a sentence.

No handover. A task started on one device cannot be continued on another. You begin again, and the context you built up is lost.

The same permissions in every body. An assistant allowed to send an email from a laptop should not inherit that permission unchanged when it is driving something with wheels. Rules have to depend on what the body can do.

What one assistant should look like

KyberBot is pre-launch; this is the design we are building it to.

One identity, one memory. KyberBot is the same assistant on every device you own. It answers to the same identity, works from the same memory and keeps one record of what it did. A body is a set of senses and hands; the assistant does not change when you change devices.

Each body says what it can do. The forms are deliberately different, as Buy it or build it: the five forms of KyberDeck explains. The card hears you and shows one line. The band works by voice and haptics when your hands are busy. The pocket deck has a screen and a real keyboard for work that deserves them. The node at home holds the long memory and runs the heavier jobs. A robot moves. KyberBot uses each body for what it is good at, and does not pretend a card is a laptop.

Sync between your own devices. Your devices talk to each other through your node, encrypted end to end, rather than through our servers. When nothing at home is reachable, each one works on what it has and catches up later. Memory does not have to leave home to get from your wrist to your pocket.

Context travels with the task. A note dictated to the band is a draft on the pocket deck an hour later. A question asked of the card is answered by the node’s speaker when you walk in. The work follows you; you do not follow the work.

Rules depend on the body. The policy for what KyberBot may do without asking is shared, and each body adds its own. A card does not spend money without your confirmation. A robot carries a full safety envelope, with limits on where it may go, how fast and what it may touch, which we describe in KyberBot in a robot.

The same system underneath. All of this is far simpler when every body runs the same operating system. KyberLinux is being built as one system from the wrist to the rack, so a fix, a policy or a security update means the same thing on the card as on the node.

A test you can run today

Count the assistants you live with: phone, watch, speaker, car, laptop, mail client, and the one built into each app. Then try this.

1. Tell one of them something specific: “I’m off on Friday afternoon.”
2. Ask a different one, an hour later: “Can I take a call on Friday at three?”
3. Check how the answer got there. If it got there at all, find out whether it went through a company’s server on the way.

If the second device does not know, you own several products with assistants in them, not an assistant. If it knows only because the sentence travelled through someone else’s cloud, you have one assistant, but it does not live with you. KyberBot is being built to pass the test both ways: it knows, and the knowledge never left your hands.