Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.
Rust acpagent-client-protocolai-agentsai-assistantclaudeclaude-codecodexcoding-agentscursorgeminigemini-cligrok-bot-alternativeiosiphonelinuxmacosmcpopen-sourcerustself-hosted
docs: add roadmap for cloud, network, memory and agent tracks
leepokaidf092a49c8e9
diff --git a/docs/roadmap.md b/docs/roadmap.mdnew file mode 100644index 00000000..0abba56d--- /dev/null+++ b/docs/roadmap.md@@ -0,0 +1,113 @@+# Roadmap++Status: **proposed**, 2026-11-03. Four long-running tracks, in the order the owner listed them. Each track links to the+doc that holds its current behavior and its detailed plan. Shipped work stays in those docs, not here; when a track+finishes a step, update its plan doc in the same change and trim the item below.++Rules that apply to every track: [CLAUDE.md](../CLAUDE.md) (version bumps, e2e, cross-platform UI), [docs/plans/](plans/)+(detailed plans), [docs/archive/](archive/README.md) (finished plans).++## 1. Cloud plan++Goal: a clear, sellable cloud option for users who do not want to run the relay and accounts themselves, without+changing how the host owns the logic.++Where it stands:++- The Codync cloud already carries the encrypted relay (`cloud/`, ComputerRelay DO), accounts, public routine+ webhooks and the cloud assistant connector (`mcp.codync.dev`, [cloud assistants](features/cloud-assistants.md)).+- A private relay is supported and has no accounts ([relay reference](reference/remote-relay.md)).+- The product direction (owner, 2026-10-24): one Codync-sold managed cloud subscription. The first backend is Boat+ (boat.dev); bring-your-own cloud comes later. Memoh (self-hosted per-bot cloud computers) is a possible option; its+ role is not decided yet.+- `cloud/` is deployed by hand, never by CI ([deployment](guides/environments-and-deployment.md#releasing-cloud-changes)).++Next steps:++1. Decide the managed-computer model: what a subscriber gets (a hosted computer per bot or per account, storage,+ usage limits) and which backend runs it. Write the decision in `docs/design/` before building.+2. Pick the backend (Boat first, Memoh only if its role is confirmed). Prove one end-to-end path: sign in, create a+ cloud computer, pair a phone, run a bot, read the reply.+3. Billing and entitlement on the account side, with the free app unchanged (no in-app purchase for the app itself).+4. Bring-your-own cloud: the same host API against a user's own cloud. Only after step 2 is stable.++Done when: a new user can subscribe, get a working cloud computer, and use it from the iPhone and desktop apps with+no local computer, and the relay docs describe it.++## 2. codync-network: long-term upkeep and stable bot-to-bot exchange++Goal: computers on several networks keep talking as the set of agent types grows, and bot-to-bot messages behave the+same whatever agent is on each end.++Where it stands: [codync-network](features/codync-network.md), [what's left](plans/codync-network-next.md), and+[bot collaboration](features/bot-collaboration.md). Still open there: Codync-run relays (waiting for the owner to+rent servers), the account networks, and the screen and rules items in the plan.++Next steps:++1. Close the open packages in `plans/codync-network-next.md` in build order; move finished ones into the feature doc.+2. Conformance tests for bot-to-bot exchange: one fixture per agent type (Claude, Codex, and each ACP registry agent+ that can run a bot), checking the same message flow: request, reply, timeout, refusal, and a routine that a bot may+ not run for another bot.+3. Keep `host/crates/network` at its 0.x version rule: every release that changes it bumps `codync-network`.+4. Upkeep: each release, run the conformance set against the current agent versions and record failures in+ [ACP adapter workarounds](reference/acp-adapter-workarounds.md) when they come from an adapter.++Done when: the conformance set passes on every supported agent type across two computers, on the same network, in CI+or in a documented manual run, and the network docs list no open "Beta" gaps.++## 3. Memory (codync-mem): benchmarking and optimization++Goal: measure how well bot memory works, then improve it with numbers, not guesses.++Where it stands: [context and memory](features/context-and-memory.md) and the design in+[bot memory](design/bot-memory.md). Bot memory is files (`MEMORY.md` and notes) that the bot edits; dreaming tidies them+into topic notes. The open choice is between a harness's own memory and `codync-mem`+([harness memory](plans/harness-memory.md)).++Next steps:++1. Write a benchmark set: a fixed script of conversations per bot, with questions whose answers depend on earlier+ sessions. Keep it in `host/crates/memory` tests or a fixtures folder; no real user data.+2. Metrics: recall (right fact returned), precision (no wrong or stale fact), tokens added to each turn, time to+ first token, and notes size after N dreams.+3. Run it on the current memory, then on the harness-memory option, and publish the table in `docs/reference/`.+4. Optimize the worst metric first. Keep the rule that memory is never full: dreaming moves detail into topic notes.+5. Use the result to decide the harness-vs-`codync-mem` question, and record the decision in the harness-memory plan.++Done when: the benchmark runs from one command, its results are in the repo, and the default memory choice is backed+by those results.++## 4. ACP coordination and long-term maintenance++Goal: every agent that Codync drives over ACP keeps working as adapters change, and the patches around them shrink+over time.++Where it stands: the host drives agents over ACP (`host/src/agent/acp.rs`, `host/src/agent/bot/`). Each adapter bug+patched in the host has a row in [ACP adapter workarounds](reference/acp-adapter-workarounds.md) (last checked+2026-11-02). Open upstream items include codex-acp#647 (429s and other errors sent as reply text) and the JetBrains AIR opt-in that works around it.++Next steps:++1. Make the adapter check a routine: on each release, check every registry adapter version against the workaround+ table; delete rows whose upstream fix has shipped, and add rows for new bugs in the same change.+2. Track upstream issues in one list (owner, status, which workaround it unblocks) and re-check it on the same cadence.+3. Once an adapter's rows are mostly gone, reconsider its place in the registry, or whether another implementation is+ worth it. Record the decision in the workarounds doc.+4. Keep the ACP parser tolerant (updates stay `serde_json::Value`), and add a test for each new adapter variant seen+ in the field.++Done when: the workaround table is checked on every release, each row names an upstream issue or a delete condition,+and no adapter is patched in code without a row.++## Order and dependencies++- Track 1 (cloud) sets the hosted option; it does not block the others.+- Track 2 needs the adapter list from track 4, so run track 4's routine check first.+- Track 3 feeds track 1 if the managed cloud needs a memory default.++## Open questions++- Which backend does the managed cloud use first (Boat only, or Memoh too)?+- Does the memory benchmark run in CI, or as a manual run on a dev computer?+- Who owns the adapter check each release (a routine, or the release checklist)?