Pre-launch · chapter 3/5 · hands
kyber agent swarm --planKyberAgent is how your SI gets work done. A planner writes the job down as a to-do list, sub-agents take one item each with a clean context and bring back one report, and KyberBot asks you before anything sensitive. Every agent runs in a KyberCell: sealed when it is created, network closed unless a rule opens it, every step on the record.
Three reasons a single agent doing everything at once breaks down on anything longer than a question.
One agent on a long job carries every page it has read and every dead end it tried. By the second hour the window is crowded with history, the decisions get worse and the bill gets bigger.
An agent with a shell, your credentials and the open internet is one bad web page away from doing something you never asked for. A sentence in a prompt is a request, not a fence.
When something goes wrong there is a chat log and a guess. No list of what ran, what was read, what left the machine and which rule allowed it.
A swarm is three moves, repeated until the list is empty.
KyberBot hands over a goal. The planner writes it down as a to-do list in a file rather than in its head, and revises it in the open as the work teaches it something.
Each item goes to a sub-agent with a fresh context and only the files and tools that item needs. It works in its own KyberCell for as long as the job takes.
A sub-agent returns one report, not its whole history. The planner ticks the list, KyberBot asks you before anything sensitive, and the answer comes back to you.
Each line is a promise about how the agents behave, written the way we intend to document it.
| command | what it does |
|---|---|
| kyber agent plan | Turns a goal into a to-do list in a file the whole swarm can read. The plan is revised where you can see it, never rewritten in silence. |
| kyber agent spawn --sub | Starts a sub-agent with a fresh context for one item on the list. It hands back one report and its working files; the scratch work stays behind. |
| kyber cell create --deny-net | Seals a new KyberCell: files and processes fixed at creation, network closed. Each program that needs out gets its own rule, adjustable while the cell runs. |
| kyber agent skill add | Gives the swarm a skill: a readable folder of instructions and scripts, loaded only when a task calls for it. |
| kyber agent ask bot | Stops before anything sensitive and asks KyberBot, which asks you. The agent waits; it does not guess. |
| kyber agent trace | Prints the trajectory: every step, every tool call, every file touched and every connection opened or refused, in order. |
Illustrative: the commands describe behaviour. They are not a released CLI.
The pattern is known. What we add is that every part of it runs on hardware you hold, under rules you can read.
The plan is a file, not a thought. You can read it, change it mid-run, and see which item each sub-agent is working on.
Each one takes a single item, starts clean and returns one report, so the planner's own context stays small enough to keep thinking clearly.
Notes, drafts and intermediate results go into files, not into the conversation. Long-running work survives a restart and stays inspectable.
Instructions and scripts packaged as folders and loaded only when a task needs them. Readable, versioned, and yours to write.
Small models on your deck for the near work, larger ones where you allow. Whichever weights do the thinking, the plan, the cells and the policies stay the same.
Set points for spend, confidence and correction rate. When one drifts, the swarm narrows its own scope and hands more back to KyberBot instead of pressing on.
Agents are where the system does the work. KyberBot sends them, KyberLinux holds each one in its cell, and KyberFusion lends power when a deck is not enough.
kyber stack --from you
Your data stays yours at every step: a sub-agent sees only what its item needs, and nothing leaves its cell unless a rule you can read says so. Tokens settle compute between members; they are not an investment, and this is not an offer.
An agent that can run code can run the wrong code, so none of them runs loose. Each gets a KyberCell: an isolated sandbox on KyberLinux whose files and processes are fixed when it is created, with the network closed until a rule opens it. The policies live in the cell, outside the model, where no conversation can argue them away.
Long work fails when nobody can see the plan. In KyberAgent the plan is a file, the swarm reports against it, and a homeostat watches cost, confidence and how often its work gets corrected. When one of them leaves its range, the swarm slows down and asks rather than spending its way through.
Something that works on your behalf earns trust by saying plainly where its edges are.
KyberAgent is pre-launch. The repository opens when there is something in it worth reading.
The deep-agent loop running inside KyberCells on KyberLinux, tested against real long-running tasks rather than a benchmark.
A small group sending real work from KyberBot to swarms on their own hardware, while the policy language and the trajectory format take their final shape.
Source, the cell specification, the policy language and the trajectory format published together, so the whole thing can be audited and forked.
KyberAgent is the swarm of agents your SI sends to do the work — a planner with a to-do list and sub-agents with fresh context that each return one report — with every agent sealed in a KyberCell and every step on the record.
Super Intelligence. Most of the industry still calls it by an older name, which the footer of every page spells out. We say SI because of what is coming, and because of whom we think it should belong to: the people who use it, not the companies that rent it out.
An isolated sandbox for one agent. Its files and processes are fixed when it is created, its network is closed unless a per-program rule opens it, secrets are injected only at the endpoint they are authorised for, and every step is logged as a trajectory. KyberLinux provides the isolation.
Because context is the scarce resource. A planner that hands each item to a sub-agent with a fresh context, and gets back one report, stays clear-headed on work that would drown a single agent. Each sub-agent also gets only the files and permissions its own item needs.
On KyberLinux, locally on a KyberDeck or in KyberFusion when the work outgrows your hardware. Any model can be plugged in: small ones on the deck, larger ones where you allow. The plan, the cells and the policies stay the same whatever does the thinking.
KyberAgent is the hands. KyberDeck is the hardware you hold, KyberBot is the assistant that knows you and sends the work, KyberLinux is the system that keeps each agent in its cell, and KyberFusion is the sovereign cloud that lends power when a deck is not enough — owned by the people who use it.
That is what KYBERIOS is for: the branch of the Kyber stack for small businesses, where swarms run orders, invoices and stock in KyberCells under the company's own policies.
An assistant that only talks is a good adviser. The moment it has to do something — read four hundred pages, compare three suppliers, fix a build at two in the morning — it needs hands, and hands are where trust gets spent. Until now the answer has been one model, one endless conversation and your keys in its pocket.
Our answer is many hands, each in a room of its own. A planner that writes the work down, sub-agents that start clean and report once, a cell around every one of them with the door shut until you open it, and a record of every step. Work you can delegate should be work you can read afterwards.
A cell is only as strong as the floor it stands on. Underneath every agent is a system built for exactly this, small, verified and the same everywhere, and that is the next chapter.
Two sub-agents return contradictory results and the planner must pick one. Why a vote is the wrong tool, what evidence on a claim means, and when the question goes to you.
A long task without a budget runs until the money or the patience ends. What a budget per task covers, what the planner does when a share runs out, and how a stop is resumed.
On Android XR an agent runs multi-step tasks on the phone while the glasses watch and listen. Where those steps run, with what rights, and what a KyberCell does differently.
The waitlist goes live soon. Until then, the blog is where the design gets argued.
No form yet, no data collected — just come back.
