CyberCode: A Claude-Code-Style Desktop Agent with Persistent Memory and Remote Control

What CyberCode Is and Who It Is For

CyberCode is a local agent that runs in a TypeScript/Bun codebase and presents itself through both a terminal TUI (built with Ink) and a Tauri + React desktop application. It is designed for engineers who want a Claude Code-style coding assistant but do not want to be locked to a single model provider, need a graphical interface, or require remote access when away from their computer.

The core additions over a basic Claude Code clone are permanent memory and self-evolution, context management, a code graph for local knowledge, model and provider decoupling, and integration with remote messaging platforms. The README states the project as a partner rather than a tool.

On the model provider side, CyberCode supports Anthropic-compatible endpoints, OpenAI-compatible endpoints via a proxy such as LiteLLM, and local models. The .env.example shows configurations for MiniMax, OpenAI through LiteLLM, DeepSeek through LiteLLM, and OpenRouter.

Installing CyberCode CLI

The CLI installer handles Bun and PATH configuration automatically. On macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/wk42worldworld/cybercode/main/scripts/install-cli.sh | bash

On Windows PowerShell:

irm https://raw.githubusercontent.com/wk42worldworld/cybercode/main/scripts/install-cli.ps1 | iex

After installation, start the agent in any project directory:

cybercode

The README documents a set of common CLI commands. The table in the README lists the commands in their original form:

cybercode "解释这个仓库"
cybercode -p "修复失败的测试"
cybercode -c
cybercode -r
cybercode --model <model>
cybercode mcp --help
cybercode plugin --help
cybercode doctor

The first command starts the agent with an initial task; the -p flag prints the result and exits, which suits CI use; -c continues the most recent session; -r lets you select and resume a saved session; --model specifies the model for the current session; doctor runs the environment diagnostic. The desktop application is a separate download available from the GitHub releases page and supports macOS, Windows, and Linux.

Persistent Memory and Self-Evolution

CyberCode's memory system is the feature that most distinguishes it from a basic coding assistant. The README describes it as distilling stable communication preferences, project knowledge, and cross-task working methods from long-term collaboration. New sessions do not start from scratch because the agent carries forward what it learned from previous interactions.

This is not a hidden background process. The desktop application shows two views of what the agent has learned: what CyberCode knows about you, and what working methods it has distilled. Each entry shows its source and category. Individual items can be edited or deleted. The README states that the underlying memory files and learning records are user-controlled.

Repeated successful work patterns can be promoted to Skills, which are reusable execution templates. This is the self-evolution aspect: effective approaches accumulate as reusable artifacts rather than fading between sessions. The README does not specify the exact format or storage location of these memory files, but it explicitly says the user controls them.

Context Management and Code Graph

CyberCode includes a multi-layer context optimization system. The README names six layers: Lite baseline cleaning, smart trimming, lazy-programmer strategy, Caveman response compression, RTK tool output compression, and a code graph. Each layer can be enabled or disabled independently. The panel shows each layer's current state, scope, and estimated savings range. The README notes that these are transparent estimates rather than guaranteed billing reductions.

The code graph indexes files, symbols, references, calls, and include relationships in the local repository. For tasks involving code structure, CyberCode provides a graph-ranked compact context before reading files at large scale, and exposes deeper graph tools to the running agent. The README suggests this is particularly useful for understanding unfamiliar repositories, impact analysis, and cross-file refactoring.

The knowledge space in the desktop app is accessible through a graph icon in the right sidebar. It supports symbol search, architecture and file layout views, node details, drag-to-zoom, and index rebuilding. Users can also add their own local files or folders to the knowledge space via drag-and-drop, with full-text search and binary file metadata indexing. Removing a source deletes only CyberCode's generated index, not the original files.

Remote Control and Scheduling

A Telegram adapter and a Lark (Feishu) adapter let users drive CyberCode sessions when away from their computer. The README describes these as passing session content and permission requests back to the user. This means the agent can continue running tasks and prompt for approval through the messaging app rather than requiring the user to be at the desk.

Scheduled tasks are also supported, covering both one-time and recurring local jobs. The README gives repository maintenance and routine checks as examples of tasks suited for scheduling. The terminal TUI and desktop app share the same local agent core, so scheduled tasks run through the same tool and memory system as interactive sessions.

Background agents handle tasks that run while the user is not actively watching the session. The README describes the work as sharing the same workflow rather than being separate products.

Model and Provider Management

CyberCode decouples model capability from product capability. The README states that regardless of whether you connect through the official Anthropic path, an Anthropic-compatible interface, an OpenAI-compatible proxy, or a local endpoint, the desktop workflow, tools, and memory capabilities stay consistent.

For models without stable web-search capability, CyberCode provides a model-agnostic local web search fallback supporting real-time search, domain filtering, caching, and GitHub Trending. The provider management panel in the desktop app handles adding, testing, and setting default providers without leaving the interface. The Agent Nodes feature exposes configured models and routing chains as OpenAI Chat Completions and Anthropic Messages endpoints with independent cc_... keys, so external agents can call them without receiving the underlying provider keys.

Limitations and Maintenance

CyberCode has no license file listed in the repository metadata (license: unknown). The README does not address licensing terms. Teams that need a clear license for commercial use should check the repository directly before adopting it.

The codebase is TypeScript and uses Bun as its runtime. Deploying it alongside Python-heavy data or ML toolchains may require maintaining two runtime environments. The dependency list in package.json is long, including Anthropic SDK, AWS Bedrock SDK, MCP SDK, OpenTelemetry packages, Ink, and several smaller utilities.

The web session feature uses user-supplied cookies or tokens. The README explicitly notes that its stability and terms-of-service risk is higher than official API access, and that it does not bypass authentication or region restrictions.

The last push was on 2026-09-25, and the most recent release, v1.1.26, was tagged on 2026-09-28, indicating active development. The rapid minor version cadence (v1.1.24, v1.1.25, and v1.1.26 all within one week) suggests the project is moving fast. LangChain or LlamaIndex combined with a retrieval-augmented generation pipeline would be the closest alternative for the knowledge and memory aspects, though neither provides a ready-made TUI or Telegram integration.

Editorial conclusion

CyberCode suits engineers who want a local AI coding agent that builds up persistent context about their projects and work style, and who need to drive it remotely through Telegram or Lark when away from their desk. The desktop app, context optimization layers, and code graph set it apart from simpler terminal-only tools. The trade-off is complexity: the dependency tree is large (Bun, Tauri, a growing list of npm packages) and the release cadence is rapid with versions v1.1.24 through v1.1.26 all appearing within a week. Before adopting it for team use, verify that the Agent Nodes feature and its cc_... key management model fits your security requirements, because the README notes that web session access carries higher risk than official API access.

Frequently asked questions

Official sources

1. Issues
2. README
3. Releases
4. wk42worldworld/cybercode on GitHub