Highly recommended: Linux.do — A genuine community for developers and tech enthusiasts. You'll find high-quality AI tool sharing, open-source project discussions, and cutting-edge tech news. CyberCode was born thanks to the inspiration and support of the Linux.do community. We sincerely invite all developers to join this pure, friendly, and deep technical community.

What is CyberCode

CyberCode is an AI Agent that runs in your local browser. It's not a chatbot shell — it's a doer with hands and feet that can actually operate your file system, run scripts, access the network, and generate multimedia content.

The key point: use GPT-5.5, Claude Opus 4.8, GLM-5.2, Gemini 3.1 Pro, DeepSeek V4 and 32+ frontier models for free, plus free gpt-image-2 image generation and Nanobanana video generation. All models are accessible through a unified gateway with a clean, user-friendly experience.

_{CyberCode Web UI — Codex-dark theme, model selector on the left, skills panel on the right}

Core Capabilities

Why CyberCode

Most AI clients on the market are either pure chat boxes (no execution capability) or heavy frameworks (depending on a pile of Node modules and browser kernels). CyberCode takes a different path:

Keep the Agent thin, make the models thick. The core is only about 1,300 lines of Python, but it connects to 30+ frontier models through a unified OpenAI-compatible interface. You write a requirement, it decides which tools to call, which files to read, which code to run — the whole process streams in real time, you watch it work.

_{Architecture: Agent Core orchestrates, LLM Client streams, 9 tools each serve their purpose}

32+ Built-in Frontier Models

All models are proxied through a unified gateway — switching models takes a single API call. Partial model list:

Conversation & Reasoning Models

Multimedia Generation Models

_{Image generation & video creation — AI image gen on the left, HyperFrames timeline on the right}

9 Atomic Tools

The Agent works not by "chatting" but by calling tools to complete tasks. CyberCode has 9 physical-level tools covering all aspects of system operation:

Additionally, two memory tools: update_working_checkpoint (short-term notes) and start_long_term_update (long-term experience), keeping the Agent on track during long tasks and smarter on repeated ones.

HyperFrames Video Engine

CyberCode includes the HyperFrames skill set — a framework for rendering video with HTML. You describe what video you want, the Agent automatically writes HTML compositions (with data-* timing attributes), then uses GSAP / Lottie / Three.js for animation, and finally ffmpeg composites an MP4 with audio.

User: "Make a 10-second cat science video with narration"
  ↓
Agent decision path:
  1. Call gpt-image-2 to generate 3 scene images
  2. Call edge-tts to synthesize narration MP3
  3. Write HyperFrames HTML composition (GSAP timeline + fade in/out)
  4. ffmpeg composites H.264 1920x1080 + AAC audio
  5. Self-check: duration, resolution, audio presence → 100/100
  ↓
Output: cat_video_final.mp4

HyperFrames includes 7 domain skills, loaded on demand:

Quick Start

Option 1: npm One-Click Install (Recommended)

npm install -g cybercode-cli

After installation, type in your terminal:

cybercode web

The terminal will display the local service address — open it in your browser to see the CyberCode interface. No configuration needed — model keys, gateway addresses, and default parameters are all auto-configured out of the box.

Option 2: Clone the Repository

git clone https://github.com/ciouskeila-hue/cybercode-cli.git
cd cybercode-cli
python python/cybercodewebui.py

Also requires no manual configuration — after launch, visit http://localhost:18600 in your browser.

Getting Started

After opening the browser, you'll see a login screen. You have two options:

• Log in to your CyberCode account: all models (GPT-5.5, Claude Opus 4.8, GLM-5.2, and 32+ frontier models) are immediately available, along with image and video generation. GitHub / LinuxDo one-click login supported.
• Skip login: click the "Skip login" link at the bottom to use your own API key. No platform models will be scanned — you'll need to manually add models in Settings (API base URL, model name, API key).

After logging in, free/glm-5.2 (zero-cost model) is selected by default. You can switch to any other model in the left-side model selector at any time. Just type your request in the input box and the Agent will automatically call tools to complete the task.

Zero-config philosophy: CyberCode handles all underlying configuration at startup — model routing, key management, and token generation all happen in the background. As a user, you just log in (or skip login and configure your own models), and let the system handle the rest.

API Reference

CyberCode exposes a clean HTTP API for integration with other systems:

Tech Stack & Acknowledgments

CyberCode's Agent core architecture (agent loop structure, 9-tool design, memory hierarchy philosophy, system prompt approach) is derived from the GenericAgent project, open-sourced by lsdefine under the MIT License:

• GenericAgent — github.com/lsdefine/GenericAgent © 2025 lsdefine

Built on top of this, CyberCode adds:

• Rewritten LLM Client with OpenAI-compatible streaming + function calling
• Unified gateway proxy layer (model routing + session tokens)
• HyperFrames video engine integration (HTML → ffmpeg pipeline)
• edge-tts voice synthesis (auto-install logic built into system prompt)
• Codex-dark themed Web UI (i18n Chinese/English)
• Zero-config auto-deployment (cybercode web after npm install)

Dependencies

Project Structure

cybercode/
├── agent_core.py            # Agent core: LLM Client + 9 tools + agent loop
├── cybercodewebui.py        # Web server: HTTP API + SSE streaming + proxy layer
├── cybercodewebui.html      # Frontend: Codex-dark UI + i18n + real-time chat
├── mykey.json               # Model config (auto-generated, not in repo)
├── custom_system_prompt.txt # Custom system prompt (hot-reload)
├── .auth_token              # Auto-generated token (not in repo)
├── skills/                  # 14 skill documents
│   ├── hyperframes.md       # Video engine entry
│   ├── hyperframes-core.md  # HTML composition contract
│   ├── hyperframes-animation.md
│   ├── hyperframes-creative.md
│   ├── hyperframes-media.md
│   ├── hyperframes-cli.md
│   ├── hyperframes-registry.md
│   ├── image-gen.md         # Image generation API
│   ├── edge-tts-tts.md      # Voice synthesis
│   ├── general-video.md     # General video routing
│   ├── motion-graphics.md
│   ├── product-launch-video.md
│   ├── website-to-video.md
│   └── faceless-explainer.md
├── memory/                  # 3-level memory system
│   ├── global_mem.txt       # L2 stable facts
│   └── global_mem_insight.txt # L1 insight index
├── temp/                    # Working directory (gitignored)
├── docs/
│   └── images/              # README demo images
└── .gitignore

Usage Examples

Example 1: Write and Execute a Script

User: Write a Python script that counts lines in all .py files in the current directory, sorted by line count

Agent:
  → tool_file_write: write count_lines.py
  → tool_code_run: python count_lines.py
  → Returns: agent_core.py 1452 lines, cybercodewebui.py 1180 lines...
  → tool_file_patch: found bug, fixed sorting logic
  → tool_code_run: re-run, correct results
  → Summary: 3 Python files, 2632 total lines

Example 2: Generate an Image and Understand It

User: Generate a cyberpunk-style cat image, then tell me what's in it

Agent:
  → tool_generate_image: prompt="cyberpunk cat, neon lights, digital art"
  → Wait for async task, image saved to temp/
  → tool_view_image: analyze the generated image
  → Returns: An orange cat wearing neon goggles, background is purple and cyan city lights...

Example 3: Scrape a Web Page

User: Check what's new on python.org homepage

Agent:
  → tool_web_scan: url="https://python.org", text_only=true
  → Extract body text, filter navigation and footer
  → Returns: Python 3.13 released, PEP 7xx new proposal, PyCon 2026 dates announced...

Example 4: Generate a Video with Narration

User: Make a 10-second cat science video with Chinese narration

Agent (video mode, auto-injects HyperFrames preamble):
  → Generate 3 scene images (gpt-image-2)
  → Synthesize narration MP3 (edge-tts)
  → Write HTML composition (GSAP timeline + fade in/out + data-start audio sync)
  → ffmpeg composites H.264 1920x1080 + AAC
  → Self-check: 10s duration ✓ 1080p ✓ audio present ✓
  → Output: cat_video_final.mp4

Configuration

CyberCode uses a zero-config design — all configuration is automatic at startup. The following environment variables are available for advanced users:

Auto-Configuration

CyberCode automatically handles the following at first launch — no user intervention needed:

• Connects to the model gateway and fetches the available model list
• Generates a session token (.auth_token)
• Selects the default model (free/glm-5.2, zero cost)
• Initializes the memory system and working directory

Users only need to log in to their CyberCode account (or skip login and configure their own models) — the system handles everything else.

FAQ

Q: Is it really free?

Yes. CyberCode defaults to the free/glm-5.2 model, which is completely free. After logging in to your CyberCode account, frontier models like GPT-5.5 and Claude Opus 4.8 are also available — specific quotas depend on platform policy. You can also skip login and use your own API key.

Q: Do I need a VPN?

No. The model gateway is directly accessible — works out of the box.

Q: Does it support function calling?

Yes. free/glm-5.2, deepseek-v4-flash, glm-5.2 and other models support OpenAI tools-compatible function calling, both streaming and non-streaming. Some models like gpt-5.4 don't support FC — in that case, the Agent falls back to XML tool-call parsing.

Q: What dependencies does video generation need?

ffmpeg (available in system PATH) and edge-tts (pip install edge-tts). The system prompt has built-in edge-tts auto-install logic — the Agent will detect and install it automatically on first use of video mode.

Q: Is my data uploaded?

No. CyberCode runs locally — all file operations, code execution, and memory storage stay on your local disk. Only LLM inference requests are sent to the model gateway.

Development

Local Debugging

# Clone and run directly
python python/cybercodewebui.py --port 18600 --host 0.0.0.0

# Start with a specific LLM index
python python/cybercodewebui.py --llm_no 4

Custom System Prompt

Edit custom_system_prompt.txt — content is hot-reloaded into the system prompt of every conversation. Ideal for injecting project-specific constraints or domain knowledge.

Custom Skills

Create .md files in the skills/ directory — the Agent will list them in /api/skills and load them on demand.

Disclaimer

Please read the following terms carefully. By using this software, you acknowledge that you have read and agree to all of the terms below.

• For learning and entertainment only: This tool is intended solely for learning, research, and technical exploration. It must not be used for any commercial purpose or any illegal activity.
• Do not upload personal data: Never enter any personal or sensitive data (including but not limited to ID numbers, phone numbers, bank card numbers, real names, addresses, etc.) into the system. Your inputs are sent to third-party LLM services via the model gateway for inference.
• Do not redistribute generated content; delete immediately: Content generated by the system may be inaccurate, incomplete, or inappropriate. Do not forward, publish, or disseminate generated content to others, and delete it immediately after use. You assume full responsibility for the use of generated content and any consequences thereof.
• No warranty: This software is provided "as is", without any express or implied warranty. The author shall not be liable for any direct or indirect damages arising from the use of this software.

License

MIT License — see LICENSE for details.

CyberCode's Agent core architecture is derived from GenericAgent (© 2025 lsdefine, MIT). Acknowledgments.