FutureOS

One AI agent across terminal, desktop, mobile and chat apps — sharing the same sessions and memory.

Stars
★ 112
Last updated
today
License
MIT
Primary language
Rust

At a glance

How it runs
CLIDesktop appSelf-hosted service
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free tier plus a paid hosted plan
Setup effort
Medium · a few setup steps
You'll need
Rust (for building the mobile iOS app from source)macOS Seatbelt or Linux Bubblewrap (for sandboxed execution)Shell / CLINetwork accessLocal filesystem
Typical use
Developers who want the agent to read code, edit files and run commands from a terminal workbench while checking progress from a phone.
Not a fit if
  • Users who want a zero-config, purely graphical start
  • Teams that need fully offline operation with no external account or relay
  • People who only want a browser-based tool without installing a local host

What does this agent do, and when should you use it?

FutureOS is a personal AI agent system written in Rust, built around a single gRPC agent that drives a terminal TUI, a desktop app, Android/iOS mobile apps, a CLI and IM bots. Every surface attaches to the same sessions, memory and skills, so a task started on a workstation can be checked from a phone. Tool execution has four safety tiers (off, manual, sandbox and auto), backed by macOS Seatbelt, Linux Bubblewrap or Windows restricted-token write protection. The phone↔host channel is end-to-end encrypted (Noise handshake, ChaCha20-Poly1305 records) and the relay can be self-hosted. For models you can bring your own OpenAI- or Anthropic-compatible endpoint and key, or sign in to the FutureOS provider to have keys and a model list provisioned. A goal control plane with durable goals, event-sourced state and verification gates supports runs of 24+ hours.

Running future host turns a machine into a FutureOS host for local runs, scheduled tasks and paired remote desktops; future tui or the desktop app attaches to it over gRPC. The agent reads workspace files, runs shell commands and calls built-in skills (image read and generation, PDF/Word parsing, web search, browser control, slides, software install, and the /future-goal orchestrator), folding each reply's process into an expandable tree of tool calls and thoughts. Sessions are stored as JSONL and can be forked, cloned and navigated as a tree. future remote devices add prints a pairing invitation; the mobile app can hold several desktops at once in one merged recent list and take control of a session. Scheduled tasks re-run a prompt plus working directory and model/thinking level on an interval or calendar cadence, each run recorded in a ledger.

  1. Developers who want the agent to read code, edit files and run commands from a terminal workbench while checking progress from a phone.
  2. Researchers who kick off a 24h+ investigation on a server at night and review results and verification gates on a phone in the morning.
  3. Individuals or small teams deploying the agent on an embedded board, GPU server or cluster and reaching it from any device.
  4. Users handling untrusted content who need sandboxing or manual approval before any file or shell action.
  5. Knowledge workers automating recurring prompts (daily digests, routine checks) with per-run records.

How do you install or deploy this agent?

On macOS and Linux the official script auto-detects the platform: macOS gets the signed app (arm64/Intel), Debian/Ubuntu gets a .deb with the desktop app and the future CLI, and other Linux distributions get a portable tarball.

curl -fsSL https://dl.future-os.cn/install.sh | bash

On Windows, PowerShell runs the signed installer silently:

iex (irm https://dl.future-os.cn/install.ps1)

The Android app is on the download page and pairs with a desktop you already run. iOS has no build on that page yet — build it from source in the repository's mobile/ directory. Per-platform toolchains and GUI packaging are covered in docs/guide/build-and-install.md.

How do you use this agent?

Configure at least one model provider first. The hosted path uses device-flow sign-in to provision keys and a model list:

future auth login

With your own key, write it to ~/.future/agent/auth.json, keyed by provider name:

{
  "openai": { "type": "api_key", "key": "sk-..." }
}

For providers outside the built-in catalog, declare everything in ~/.future/agent/models.json:

{
  "providers": {
    "my-provider": {
      "apiKey": "sk-...",
      "baseUrl": "https://my-api.example.com/v1",
      "thinkingLevels": ["off", "low", "high"],
      "models": [{ "id": "my-model" }]
    }
  }
}

Then start the host and attach the terminal UI to it:

future host
future tui

Remote access needs a FutureOS account for pairing on the official relay and prints an invitation:

future auth login
future remote devices add

With a self-hosted relay, pass --relay URL to the host to keep the same protocol, pairing and encryption without the Future platform account.

What are this agent's strengths and limitations?

Pros
  • A single Rust core drives the TUI, desktop app, mobile apps, CLI and IM bots, with the same sessions, memory and skills across all of them.
  • Four execution tiers (off, manual, sandbox, auto) map to macOS Seatbelt, Linux Bubblewrap and Windows restricted-token protection, so permissions can be tightened for untrusted content.
  • Phone↔host traffic is end-to-end encrypted (Noise handshake, ChaCha20-Poly1305), and future relay init / future relay serve let you self-host a relay that only carries ciphertext.
  • Model flexibility: a built-in catalog, any OpenAI- or Anthropic-compatible endpoint via models.json, or the hosted provider with provisioned keys.
  • The goal control plane adds durable goals, event-sourced state and verification gates for long-horizon runs rather than relying on prompting alone.
  • JSONL session history supports fork, clone and tree navigation for branching and revisiting work.
Limitations
  • The desktop starts at Unrestricted (off); you must switch to Manual, Sandboxed or auto before working with untrusted content, which is easy to overlook.
  • Sandbox guarantees differ by platform — Windows only gets restricted-token write protection.
  • Pairing on the official relay requires a FutureOS account; opting out means hosting your own relay and passing --relay.
  • There is no official iOS build; the app must be compiled from mobile/, which raises the bar for non-developers.
  • A full setup spans host, clients, account and relay, so the first working run takes several configuration steps.

How does this agent compare with similar options?

The repository's topic list positions it as an openclaw-alternative, but the README does not detail the comparison, so no feature-by-feature contrast is made here.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
FutureOS This agent 52 · Major gaps CLIFreemium ★ 112 today Rust OpenAI API · Claude API
NextClaw 58 · Major gaps Desktop appFree + model costs ★ 262 today TypeScript Codex · Claude Code
LazyMind 50 · Major gaps Desktop appFree + model costs ★ 475 today Go Codex
AnythingLLM 48 · Major gaps Self-hosted serviceFree + model costs ★ 68k today JavaScript OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
52/ 100 5-point scale 2.6 / 5
Trust 12/29
Reliability 9/14
Adaptability 10/18
Convention 10/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

least_privilege: README and the sandbox test record show four approval tiers (off/manual/sandbox/auto), macOS Seatbelt, Linux Bubblewrap, and Windows restricted-token/ACL write protection, with per-backend boundary receipt tests; that is real evidence of privilege layering, but the desktop starts at Unrestricted (off), so the default posture is permissive — 2. user_confirmation: manual tier and rule-file approvals (fail-closed on unknown actions) are test-backed, but the auto tier hands would-be interruptions to a model reviewer, partially delegating confirmation — 2. data_flow_transparency: README asserts Noise + ChaCha20-Poly1305 end-to-end encryption and a self-hostable relay, but no protocol implementation or key-management detail is present in the reviewed files, so it is assertion rather than verifiable evidence — 1. sensitive_data_handling: API keys are written in plaintext to ~/.future/agent/auth.json with no documented encryption, permission tightening, or rotation; the sandbox doc admits snapshot/credential limitations without detail — 1. dependency_security: only lockfiles and pinned Tauri versions are visible; no audit, SBOM, or vulnerability-response process — 1. external_effects: scheduled tasks run 'at full permission', plus IM bridges and remote control, are documented as capabilities without isolation or revocation for external writes — 1. rollback: sessions are forkable and the goal plane is event-sourced, but install scripts, sandbox ACL changes, and scheduled tasks have no documented rollback path — 1. source_attribution: an MIT badge and a THIRD_PARTY_NOTICES link exist, but the publisher is unverified and installers pull binaries from dl.future-os.cn, so provenance cannot be closed inside the repository — 1.

Reliability9 / 14 · 3.2/5

self_consistency: README, build guide, sandbox record, and channel-runtime record agree on CLI embedding, host mode, and sandbox tiers, and the test record explicitly separates 'the test was wrong' from 'the code was wrong' — 2. dependency_availability: the build guide lists per-platform dependencies (pinned Rust 1.99.1, Node 24+, mold, WebKitGTK, Bubblewrap) and states behavior when they are missing (installer refuses without shasum/sha256sum) — 2. failure_messages: the troubleshooting table covers no-agent, gRPC, no-model, and build failures, and the test record gives concrete panic text and error-code classification — 2; end-user runtime diagnostics still lean on future doctor, so not 3.

Adaptability10 / 18 · 2.8/5

audience_and_scenarios: clearly separates end users (one-line install), developers (source build), headless hosts, mobile, and IM scenarios — 2. capability_boundaries: the sandbox guide and test record state per-platform capability differences (Seatbelt/Bubblewrap/restricted token, pwsh versions, unmeasured platforms) honestly — 2. trigger_precision: scheduled tasks support interval/daily/weekly triggers, but deduplication, missed-run catch-up, and overlapping runs are undocumented; skill and goal triggers are described only in prose — 1. environment_fit: covers macOS/Linux/Windows/Android/iOS, static musl CLI, and older distro compatibility — 2.

Convention10 / 18 · 2.8/5

information_architecture: README has nav anchors, a feature table, quick start, and troubleshooting; docs are split into guide/wiki/architecture/testing — 2. install_notes: the build-and-install guide is unusually thorough, with per-platform commands, an artifact-naming table, and explicit verification/skip-verification risk notes — 3. naming_stability: artifact filenames follow templates, but versions look like 0.0.2-<hash>, test/nightly suffix rules are complex, and CLI/GUI versions are independent — 2. examples_and_faq: configuration examples (auth.json, models.json, thinkingLevels) and a troubleshooting table exist, but there is no user-facing FAQ or end-to-end walkthrough — 2. known_limitations: the sandbox record lists unmeasured platforms, unreachable branches, CI flakiness, and pty limits — 2. license: the README badge says MIT + Apache-2.0 while the task metadata says MIT, and no LICENSE text is in the reviewed files — 1. versioning_changelog: only a version script and release-channel naming; no CHANGELOG or semver policy — 1. maintenance_responsibility: the publisher is unverified and there is no maintainer, security-response SLA, or governance statement beyond a SECURITY.md link — 1.

Effectiveness7 / 13 · 2.7/5

output_usability: the TUI folds tool calls, sessions fork, and one session spans devices — designs aimed at real output, with desktop/mobile screenshots as supporting evidence — 2. marginal_value: a unified Rust core with multi-surface access and a long-horizon goal plane is differentiated, but much of the capability depends on an external future-skills submodule and hosted services — 2. cost_benefit: installation requires piping a remote script to a shell, the desktop defaults to unrestricted permissions, and users must supply model keys or sign in; the benefit does not clearly outweigh the setup and trust cost — 1.

Verifiability4 / 8 · 2.5/5

claim_traceability: the test records carry file:line references, commands, before/after numbers, and verbatim failure output that can be re-checked — 2. cross_source_corroboration: core README claims (encryption, sandboxing, long runs) lack a second in-repo source — no protocol code, no CI result artifacts — so they rest on documentation alone — 1. fact_inference_separation: the test record separates measured numbers, inference, and uncovered areas (e.g. 'the concurrent race itself is not covered') and flags historical data as not re-verified — 2.

Risks and how to mitigate them
  • Installers pipe remote content from dl.future-os.cn into a shell (curl | bash, iex(irm ...)) and the publisher is unverified; download and review the script and check its SHA-256 before running.
  • The desktop starts at Unrestricted (off); switch to manual/sandbox before handling untrusted content, and do not treat the auto tier's model review as equivalent to human confirmation.
  • API keys are stored in plaintext at ~/.future/agent/auth.json; tighten file permissions and avoid shared hosts.
  • Scheduled tasks are documented to run at full permission with no described catch-up, overlap, or revocation handling; assess external side effects before enabling.
  • The README badge says MIT + Apache-2.0 while the metadata says MIT, and no LICENSE text is in the reviewed files; confirm the actual terms before use.
  • Core claims such as end-to-end encryption, self-hosted relay, and the long-horizon goal plane lack implementation or independent corroboration in the reviewed files and rest on documentation alone.
Evidence confidence: Low Reviewed Oct 29, 2026 Reviewed revision 6f8ad796cf0e
See the full review method →

FAQ

Can I use it without a FutureOS account?
Yes locally: the host, TUI, desktop app and local tasks do not require sign-in. The account is only needed for pairing phones or other desktops on the official relay; pointing the host at a self-hosted relay with --relay URL removes the Future platform from the path.
What does it cost?
The software is open source (MIT, with an Apache-2.0 mention in the badge). Costs come from the models you choose — bring your own OpenAI/Anthropic-compatible key and pay per use, or sign in with future auth login to use the hosted provider.
Is the sandbox a hard security boundary?
Not a blanket guarantee. The README states that sandbox availability and guarantees differ by platform, distinguishing macOS Seatbelt, Linux Bubblewrap and Windows restricted-token write protection; check SECURITY.md and the Sandbox guide before relying on it.
Why does the TUI exit saying no Agent is serving?
The TUI only attaches and never starts an agent. Run future host (or open the desktop app, or future agent) first, then future tui; for connection or gRPC errors, run future doctor.
View on GitHub ↗ Install ↓

Related agents