Zeta is a terminal workbench suite: one workspace that tiles real terminals,
plus the tools that live inside them — a coding agent, an editor, a terminal
IDE, and a file manager. It is an agent development environment (ADE), not
an IDE with a chat pane: the session is the unit of work and every pane is a
surface the agent can use. Linux is the primary platform; Windows x64 is
supported; there is no macOS build.
The Suite
Local SQLite memory engine for Zeta agents
2026-11-16
ดาว
—
เครื่องมือ
—
อัปไทม์
—
Command
Package
What it is
zetawork
@linxiraos/main
The workspace: nested-terminal workbench (Rust)
zeta
@linxiraos/main
Suite index — a bare zeta prints the help/command map
zetacode
@linxiraos/zeta
Coding agent CLI
zetaide
@linxiraos/ide
Terminal IDE (TermIDE, vendored Rust)
Every command launches standalone with its own --help; a bare zeta prints
the suite index. The workbench is the unified entry: its coding/IDE panes hand
off to zetacode and zetaide, and its editor pane is built in (the
@linxiraos/editor package name and its publish chain are reserved for that
pane's binary payload; nothing is published under it today and it declares no
command of its own).
Repository Map
The product has four layers and one rule: the runtime depends on nothing
above it, and no front-end depends on another front-end. The HTTP gateway is
an adapter, not the hub — it exists so a browser can talk to the runtime, not
because anything else needs it. document/architecture-layers.md is the full
contract; this is the orientation.
Each one is a client of the host. IM bots are a front-end too.
HTTP adapter
packages/coding-agent/src/server/web-gateway/
REST/SSE/WS over the host. zetacode serve starts it; the browser UI and remote phones consume it.
Where each directory belongs:
Path
Contents
packages/
The published runtime packages (@linxiraos/*): coding-agent, ai, agent, tui, catalog, stats, channels, wire, mnemopi, natives, utils, omptype, browser-relay, collab-web.
main/
zetawork, its own Cargo workspace: the TUI (crates/zeta-main), the native GUI (crates/zetawork-gui), and crates/sysmon (shared system sampling).
termide/
Vendored TermIDE panel library — the panels both workbenches embed — plus the zetaide entry (@linxiraos/ide). Deviations from the vendored snapshot are logged in termide/VENDOR.md.
editor/
The built-in editor pane's npm face. The payload is a termide-editor binary; the package declares no command.
crates/
Rust runtime crates compiled as native addons (pi-natives, pi-ast, pi-diff, pi-builtins, …), built by Bazel.
web-ui/
The browser UI (a diverged OMP Web snapshot, npm-managed, not a root workspace package). Two jobs only: chat in a browser, and hosting HTML plugin pages.
desktop/
The retiring Electron shell. No new code; the desktop product is zetawork's GUI.
Build infrastructure, toolchain files, patch set, LSP server table, bundled skills, image assets, ambient type shims.
Plugin layers
A plugin is TypeScript, but what it shows is a choice of layer. Pick by what
the surface needs, not by what the plugin is written in:
Layer
Surface
Use it for
Behaviour
Any front-end (tools, commands, hooks, messaging)
Work the agent performs. Rendered by nobody; identical in every client.
Declarative panel
zetawork GUI, natively
Lists, forms, charts: the GUI draws them with its own widgets and theme.
HTML page
web-ui, and zetawork's plugin column via a webview
Rich or third-party pages that cannot be expressed declaratively.
zetaide has no plugin layer, and the workbench TUI does not host plugin
surfaces — a plugin that needs the terminal reaches it through the agent's own
tools instead.
Quick Start
Install the workspace (Node 18+ or Bun on the machine):
npm i -g @linxiraos/main # or: bun add -g @linxiraos/main
zetawork # opens the workspace in the current directory
zetawork web # serves the full Web UI on loopback for your browser
zetawork doctor # suite install status + exact fixes
zetawork doctor lists every suite tool with installed/missing state and the
exact install command for what is missing. Missing tools also self-install
into a workbench pane on first use. Install any tool standalone the same way:
npm i -g @linxiraos/zeta # zetacode — coding agent CLI
npm i -g @linxiraos/ide # zetaide — terminal IDE
The editor is a workbench pane, not a standalone tool, so it has no install
line: @linxiraos/editor is a reserved package name whose payload is not
published today.
From a source checkout:
bun install
bun run build:native
bun run dev
The Workspace
zetawork is a real terminal multiplexer with product opinions, written in
Rust:
Tabs and tiled panes — each pane is a real PTY: anything that runs in a
terminal runs in a pane (a shell, a zetacode session, the editor, the IDE).
Split any pane left/right or top/bottom; panes keep a stack of pages so
one pane can hold several terminals without closing anything.
Mouse-first — every control (menu bar, tab bar, pane title controls,
page tabs) is clickable; keyboard shortcuts exist as accelerators, not as a
requirement. Switching, splitting, closing, and layout repair are all
pointer operations.
Widget panes — a clock with a clickable calendar, a pomodoro timer, and
a clipboard history pane run as native panes, not external tools.
Suite-aware — the Tools menu and zetawork doctor know the suite; a missing
tool installs itself into the pane that asked for it.
The Coding Agent
zetacode is the coding CLI (built on the OMP runtime):
A terminal coding workspace with file reading, search, patching, shell, git,
task delegation, and structured tool output.
Multi-provider model access, local configuration, OAuth flows, model
discovery, session recovery, and controllable retry behavior.
A local web workbench (zetacode serve, Next.js app in web-ui/) and a
desktop shell (zeta-desktop, Electron) that embed the same runtime — one
session tree, one settings model, one gateway API (/api/*).
Native text, image, terminal, browser, and desktop capabilities where the
host platform supports them.
An agent development environment (ADE)
The suite is not an IDE with a chatbot bolted on. It is an ADE — an Agent
Development Environment, the way an IDE is an Integrated Development
Environment: the same structure, with the first word changed from Integrated
to Agent.
IDE
ADE (this suite)
Center of gravity
the open file
the agent session
Who drives the tools
the editor drives LSP, builds, the debugger
the agent drives tools; editors and terminals are its work surfaces
Unit of work
a buffer
a session: context, tools, subagents, verification
Where the loop lives
type → build → debug
plan → execute → verify, with the human steering
Zeta keeps the IDE's shape — panes, tabs, real PTYs, LSP, an editor pane, a
terminal IDE (zetaide) — because an agent needs somewhere to work. What moves
is the center: zetacode sessions, subagent orchestration, the mesh
(agent://), extensions and skills are first-class; the editor, terminals and
file manager are the environment the agent operates in. A human can still drive
any pane directly; the suite simply assumes the agent is the primary worker and
the panes are how it observes and changes the world.
Semantic-port source for feature work, never a raw merge source
The workbench (main/) and the desktop-facing additions are ours. Vendored
projects keep their own licences and are listed in THIRD-PARTY-NOTICES.txt; the merge
procedure is recorded in document/upstream-sync.md.
Component Lineage
The distribution is assembled from parts with different origins. What a part
inherits from upstream — and what Zeta owns — is stated per component:
Beyond the OMP runtime lineage, Zeta ships its own capabilities (roadmap in
document/roadmap.md):
The workspace (zetawork) — tabs, tiled PTY panes with per-pane page
stacks, a menu bar with full mouse control, native widget panes, and suite
install/doctor integration.
Adaptive long-term tracking — ongoing session observation with standing
system guidance that keeps provider prefix caches stable across long
sessions.
Experiment measurement — per-project local experiment tracking with
metrics, directions, and baseline commits.
TypeScript custom commands — user-defined slash commands from
~/.zeta/commands/ and project command dirs, with arktype/typebox/zod
argument schemas and full access to the runtime API.
Command marketplace — install and share slash commands as Bun packages.
Channel runtime — WeChat/Feishu/Telegram bridges embedded in
zetacode serve, with plan-image routing and workspace-scoped execution tools.
Web gateway — REST API behind the web UI (/api/*), one handler module
per resource, consumed by both the browser UI and the desktop shell.
Desktop shell — Electron tray application embedding a standalone build of
the web UI plus the compiled runtime; target machines need neither Bun nor Node.
Linux downstream packaging — zeta-desktop ships as a release asset with
a frozen name/digest contract so downstream repositories (pacman et al.) can
pin and verify it; see document/release.md.
Local stats dashboard — zetacode stats observability for the coding agent.
Documentation
The repository keeps two documentation trees with different audiences:
docs/ — runtime documentation, packaged with the product. Agents
read it at runtime through zeta://docs/ (embedded in binaries and the npm
bundle; from a source checkout it reads the live tree). Covers tools,
tool-call conversion, skills, protocols, configuration, and Zeta features.
The CLI ships Simplified Chinese and English catalogues. The active language
resolves in this order:
language in the settings file (~/.zeta/settings.json) — the explicit
choice, written by /language.
ZETA_LANG / LC_ALL / LC_MESSAGES / LANG — the shell locale.
The OS UI language (Intl) — so a Chinese Windows box gets Chinese with no
configuration at all.
English when nothing matches.
/language switches live: slash-command descriptions, the composer, and every
localized panel re-resolve on the next render without a restart. Both
catalogues are complete, so the choice is per-install rather than per-build —
plugins can register their own text through the same source.
Development
# Static checks for TypeScript and Rust
bun check
# Coding-agent checks only
bun --cwd=packages/coding-agent run check
# Focused tests
bun --cwd=packages/coding-agent test test/<file>.test.ts
The primary application lives in packages/coding-agent/. Shared runtime
packages include packages/ai/, packages/catalog/, packages/agent/,
packages/tui/, and packages/natives/. The workspace lives in main/ (its
own Cargo workspace), with the vendored tree under termide/.
Platform Support
Linux is the primary platform (Linxira OS, Arch-based); Windows x64 is a
supported development/target platform; macOS is not built.
Surface
Linux
Windows
macOS
zetawork workspace (@linxiraos/main)
x64
x64
—
zetacode CLI
x64, arm64
x64
—
zetaide (@linxiraos/ide)
x64
x64
—
zetacode serve (web workbench)
x64, arm64
x64
—
zeta-desktop shell
x64
x64
—
Native text/grep and image capabilities require the platform C/C++ toolchain
when built from source; released binaries bundle the prebuilt native modules.
Upstream Policy
Zeta follows OMP only through complete, official release tags. Each release is
merged as real Git history on a temporary integration branch, then receives any
required Zeta package, brand, Bun, CI, and product adaptations in separate
commits. The exact source tag, SHA, conflict decisions, and checks are recorded
in document/upstream-sync.md.
Pi is a semantic feature source, not a raw merge source. See
AGENTS.md for the repository rules.
Commercial surfaces
Upstream ships commercial surfaces: the Stencil build service, a hosted model
catalog, the hosted /share viewer, its Homebrew tap, and OTLP telemetry.
Zeta runs none of them. The build service and telemetry are not in this tree;
every hosted endpoint the code still references is pinned in
document/upstream-commercial-assets.md
with its replacement status, and bun scripts/check-shared-infra.ts fails when
an unregistered upstream endpoint appears.
License
Zeta carries two licences, split by path:
Path
Licence
main/ — the zetawork workbench (zetawork, zeta, and its npm packages)
The root LICENSE states the split and reproduces the MIT text that
governs everything outside main/. Derived and vendored projects keep their own
licences and are listed in THIRD-PARTY-NOTICES.txt.
Commercial licensing of the workbench is available by arrangement with the
maintainers.
The workbench's editor pane is built in: @linxiraos/editor is the reserved
package name for its binary payload (the earlier TTT-derived Go payload was
removed 2026-10-16 and stays credited in source history).
简体中文
Zeta 是一套终端工作台套件:一个可平铺真实终端的工作区,加上活在工作区里的
工具——编码 Agent、编辑器、终端 IDE 和文件管理器。它是 Agent 开发环境
(ADE),不是"IDE 加聊天框":会话是工作单元,每个窗格都是 agent 可以
使用的工作面。Linux 是主力平台;支持 Windows x64;不提供 macOS 构建。
# TypeScript 与 Rust 的静态检查
bun check
# 仅编码 Agent 检查
bun --cwd=packages/coding-agent run check
# 聚焦测试
bun --cwd=packages/coding-agent test test/<file>.test.ts