Skip to content

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.

docs: add roadmap for cloud, network, memory and agent tracks

leepokaidf092a49c8e9
diff --git a/docs/roadmap.md b/docs/roadmap.md
new file mode 100644
index 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)?