These are long-range directions, not features or plans. HELLO OS does not implement any of them. Each card says why it isn't possible yet. Three include a small in-browser simulation of the underlying idea, labelled as such. See also the HELLO Cloud vision.
Move a running agent's working state (goals, plan, memory pointers) from one model backend to another mid-task and continue without loss.
Why not yet: Model internals (activations, KV caches) are not portable between architectures or vendors. Only text summaries can be handed over, and those lose information.
An agent clones itself into variants, lets them compete on a task, and merges back the best behaviour.
Why not yet: Forking prompts and configs is easy. Forking and merging learned behaviour safely is not: there is no reliable way to merge what divergent copies learned, or to bound what a fork may do.
An agent proves a property of its reasoning (e.g. 'my answer did not use data X') without revealing the reasoning.
Why not yet: ZK proofs over full transformer inference are far too expensive today, and 'belief' has no formal definition you could prove things about.
When context gets long, the agent pauses, distils raw episodic logs into compact rules, and resumes with a smaller prompt.
Why not yet: LLM APIs are stateless and have no background lifecycle. Summarisation exists, but there's no reliable signal for 'reasoning is degrading', and summaries can drop the detail that matters.
Many agents sync their dead-ends and discoveries into a shared space overnight, so each inherits the others' lessons.
Why not yet: Shared retrieval stores are possible. Merging learning across many models is limited by privacy, sync cost, and catastrophic forgetting.
Post-quantum credentials that revoke themselves the moment an agent's behaviour drifts outside its charter.
Why not yet: Post-quantum signatures exist. Detecting 'semantic drift' reliably and in real time does not, and automatic revocation on a noisy signal would be unsafe. In HELLO OS today, revocation stays with the operator.
Run a legacy binary in a sandbox, observe execution and memory, and rewrite it as modern code without documentation.
Why not yet: Dynamic tracing only covers paths you exercise, and code models are trained on static text, not live instrumentation loops.
Roll a multi-day workflow back to any step, change one tool output, and replay deterministically to see how decisions change.
Why not yet: Sampling makes LLM output non-deterministic, even at temperature 0 across hardware and batching, and external side effects (emails, payments) can't be replayed.
Agents for different organisations negotiate and sign binding SLAs, and settle disputes with cryptographic evidence.
Why not yet: Agents have no legal personhood or liability framework. Signing messages is possible (HELLO OS does it), but making them legally binding is not.
Compile abstract intent directly into executables, skipping natural-language and code intermediates.
Why not yet: Today's models predict tokens and need a symbolic bridge (code, AML) to produce reliable executable output.