zylos-core

Zylos

Zylos (/ˈzaɪ.lɒs/ 赛洛丝) — Give your AI a life

Give your AI a life.

中文

---

LLMs are geniuses — but they wake up with amnesia every session. No memory of yesterday, no way to reach you, no ability to act on their own.

Zylos gives it a life. Memory that survives restarts. A scheduler that works while you sleep. Communication through Telegram, Lark, or a web console. Self-maintenance that keeps everything running. And because it can program, it can evolve — building new skills, integrating new services, growing alongside you.

Supports Claude Code (Anthropic) and Codex (OpenAI). Fully compatible with the OpenClaw ecosystem.

---

Quick Start

Prerequisites: A Linux server (or Mac), a Claude subscription (or OpenAI Codex as an alternative runtime — Codex CLI v0.129.0+ required, 0.146+ recommended).

Zylos-managed Codex sessions use --no-daemon when the installed CLI advertises it, isolating startup from shared background-server settings. Older CLIs without this option keep their existing launch behavior. This does not change the shared daemon or your standalone Codex configuration.

curl -fsSL https://raw.githubusercontent.com/zylos-ai/zylos-core/main/scripts/install.sh | bash

This installs everything you need (git, tmux, Node.js, zylos CLI) and automatically runs zylos init to set up your agent.

All zylos init flags can be passed directly through the install script. The script installs dependencies, then runs zylos init with the flags you provide.

Full example:

curl -fsSL https://raw.githubusercontent.com/zylos-ai/zylos-core/main/scripts/install.sh | bash -s -- \
  -y \
  --setup-token sk-ant-oat01-xxx \
  --timezone Asia/Shanghai \
  --domain agent.example.com \
  --https \
  --caddy \
  --web-password MySecurePass123

When is non-interactive mode active?

Automatically when no TTY is available — e.g. Docker containers (without -it), CI runners, or cron jobs. Also when CI=true or NONINTERACTIVE=1 is set. Note: curl | bash in a terminal is still interactive (the install script redirects from /dev/tty). Use -y to force non-interactive in a terminal.

Flags:

Flag	Description	Default
-y, --yes	Force non-interactive mode (skip all prompts)	Auto-detected
-q, --quiet	Minimal output	Off
--runtime <name>	AI runtime: claude or codex	claude
--setup-token <token>	Claude setup token (starts with sk-ant-oat)	—
--api-key <key>	Anthropic API key (starts with sk-ant-)	—
--codex-api-key <key>	OpenAI API key for Codex runtime (starts with sk-)	—
--base-url <url>	Custom API base URL for Claude Code	—
--codex-base-url <url>	Custom API base URL for Codex	—
--timezone <tz>	IANA timezone, e.g. Asia/Shanghai, America/New_York, Europe/London	System default
--domain <domain>	Domain for Caddy reverse proxy, e.g. agent.example.com	None
--https / --no-https	Enable or disable HTTPS	--https when domain is set
--caddy / --no-caddy	Install or skip Caddy web server	Install
--web-password <pass>	Web console password	Auto-generated

Environment variables:

Flags can also be set via environment variables during zylos init. Resolution order: CLI flag > env var > existing .env > interactive prompt.

Environment Variable	Equivalent Flag
ZYLOS_RUNTIME	--runtime
CLAUDE_CODE_OAUTH_TOKEN	--setup-token
ANTHROPIC_API_KEY	--api-key
ANTHROPIC_BASE_URL	--base-url
OPENAI_API_KEY	--codex-api-key
OPENAI_BASE_URL	--codex-base-url
ZYLOS_DOMAIN	--domain
ZYLOS_PROTOCOL (https or http)	--https / --no-https
ZYLOS_WEB_PASSWORD	--web-password

CI, Kubernetes, and shared E2E environments should also provide GITHUB_TOKEN so zylos add and zylos upgrade use GitHub's authenticated API quota instead of the shared unauthenticated quota. See the GitHub authentication operations guide for configuration examples and fallback behavior.

Exit codes: 0 = success, 1 = fatal error (e.g. invalid token), 2 = partial success (e.g. Caddy download failed but everything else succeeded).

curl -fsSL https://raw.githubusercontent.com/zylos-ai/zylos-core/main/scripts/install.sh | bash -s -- --no-init

Installs dependencies and the zylos CLI, but skips zylos init. Run zylos init separately when ready.

curl -fsSL https://raw.githubusercontent.com/zylos-ai/zylos-core/main/scripts/install.sh | bash -s -- --branch <branch-name>

npm install -g --install-links https://github.com/zylos-ai/zylos-core
zylos init

docker run -d --name zylos \
  -e CLAUDE_CODE_OAUTH_TOKEN=YOUR_TOKEN_HERE \
  -p 3456:3456 \
  -v zylos-data:/home/zylos/zylos \
  -v claude-config:/home/zylos/.claude \
  ghcr.io/zylos-ai/zylos-core:latest

Open http://localhost:3456 to access the web console. Find your password with docker logs zylos | grep -A2 "Web Console". See the Docker Deployment Guide for Docker Compose setup, environment variables, Synology NAS instructions, and more.

On platforms without native support, use Claude Code's SSH feature to install Zylos on a remote Linux/macOS machine:

# From your local machine (any OS that runs Claude Code)
claude --ssh user@your-linux-server

Once connected, Claude is running on the remote machine. Ask it to install Zylos:

> Install Zylos on this machine

Or run the installer directly in the SSH session:

curl -fsSL https://raw.githubusercontent.com/zylos-ai/zylos-core/main/scripts/install.sh | bash

This works from Windows, ChromeOS, or any platform that can run Claude Code locally. The AI handles the setup on the remote server — no need for native platform support.

Node.js requirement: Zylos requires Node.js 20 or later. We recommend installing via nvm — the install script does this automatically. If you manage Node.js yourself, make sure to use a single, stable version and avoid switching versions after installation, as globally installed npm packages (including Zylos) are tied to the Node.js version that installed them.

# Recommended: let the install script handle it, or install manually via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
nvm install 24
nvm alias default 24

zylos init is idempotent and supports both interactive and non-interactive modes. It will:

1. Install missing tools (tmux, git, PM2, Claude Code or Codex)
2. Set up authentication (Claude: browser login, API key, or setup token; Codex: API key or device auth)
3. Create the ~/zylos/ directory with memory, skills, and services
4. Start all background services and launch your AI agent in a tmux session

Talk to your agent:

# Interactive CLI — the simplest way to chat
zylos shell

# Or attach to the Claude tmux session (Ctrl+B d to detach)
zylos attach

# Or add a messaging channel
zylos add telegram
zylos add lark

---

Architecture

graph TB
    subgraph Channels["📡 Communication Channels"]
        TG["Telegram"]
        LK["Lark"]
        WC["Web Console"]
    end

    subgraph Zylos["🧬 Zylos — The Life System"]
        C4["C4 Comm Bridge<br/>(unified gateway · SQLite audit)"]
        MEM["Memory<br/>(Inside Out architecture)"]
        SCH["Scheduler<br/>(autonomous task dispatch)"]
        AM["Activity Monitor<br/>(guardian · heartbeat · auto-recovery)"]
        HTTP["HTTP Layer<br/>(Caddy · file sharing · HTTPS)"]
    end

    subgraph Brain["🧠 AI Runtime — The Brain"]
        CC["Claude Code / Codex<br/>(in tmux session)"]
    end

    TG & LK & WC --> C4
    C4 <--> CC
    MEM <--> CC
    SCH --> CC
    AM --> CC
    HTTP <--> CC

Component	Role	Key Tech
C4 Comm Bridge	Unified message gateway with audit trail	SQLite, priority queue
Memory	Persistent identity and context across restarts	Inside Out tiered architecture
Scheduler	Autonomous task dispatch while you are away	Cron, NL input, idle-gating
Activity Monitor	Crash recovery, heartbeat, health checks	PM2, multi-layer protection
HTTP Layer	Web access, file sharing, component routes	Caddy, auto-HTTPS

---

Features

One AI, One Consciousness

Most agent frameworks isolate sessions per channel — your AI on Telegram doesn't know what you said on Slack. Zylos is agent-centric: your AI is one person across every channel. The C4 communication bridge routes all messages through a single gateway — one conversation, one memory, one personality. Every message persisted to SQLite and fully queryable.

Your Context, Guaranteed

Other frameworks lose your AI's memory during context compaction — silently, without warning. Zylos prevents this with a two-step safeguard: when context reaches 75%, the system automatically saves all memory before compaction runs. Five-layer Inside Out memory (identity → state → references → sessions → archive) ensures the AI always knows what to keep and what to compress. Your AI never wakes up with amnesia.

Self-Healing by Default

No third-party monitoring tools needed. Zylos includes native crash recovery, heartbeat liveness probes, health monitoring, context window management, and automatic upgrades — all built in. Your AI detects its own problems and fixes them. It stays alive while you sleep.

$20/month, Not $3,600

Other frameworks charge per API token. Community reports show monthly bills of $500–$3,600 for always-on agents. Zylos runs on your Claude subscription — flat rate, no per-token billing. Same AI capabilities, a fraction of the cost.

Powered by Best-in-Class AI Runtimes