A terminal-first agent that plans, runs real tools, asks when it matters, and scales to a swarm - for any kind of work, not just code.
Core is the open Rust runtime that does the work - the agent loop, tools, providers, sandbox, and memory. Desktop is the GUI product that embeds Core over a JSON-stream protocol. Same engine: run it raw in your terminal, or get the full command center on top.
The embeddable engine. One Rust binary - terminal-first agent, headless JSON-stream, MCP, OS-native sandbox, ~20 providers, ~70 tools.
The polished command center built on Core: assistants, workflows, teams, a sub-agent monitor, approvals, and a UI - for everyone, not just the terminal.
Run it with no arguments and Core finds your provider keys and drops you into a full-screen TUI - onboarding, a live sub-agent swarm, and the finished run, all in your shell.
Most agent CLIs lock you to one vendor, run tools wide-open, and never get better. Core is built the other way.
~20 providers - Anthropic, OpenAI, Bedrock, Vertex, Gemini, plus ~15 OpenAI-compatible vendors and local Ollama - behind one trait, where every quirk is config data, not a code branch. Per-request retries, key rotation, a cross-provider fallback chain, and a circuit breaker on every provider. Switching vendors is a one-line change.
Every shell command runs in an OS-native sandbox - bubblewrap on Linux, sandbox-exec on macOS - and fails closed when none is available. On Windows the default is a kill-on-close Job Object, which bounds the process but does not confine the filesystem; AppContainer is opt-in via WAYLAND_SANDBOX=appcontainer. Every outbound request passes a default-on egress gate, enforced structurally by a Clippy lint. Approval modes gate the risky calls; budget caps actually block. Real security, not a checkbox.
An offline evolutionary optimizer (GEPA) mutates and scores skill prompts across generations, and an in-session drafter auto-writes a reusable skill after three successful runs on the same task. That drafting loop is on by default: the draft is recorded into GEPA's PromptStore with full lineage and the skill router reads from it, so the library your install uses grows out of work that actually succeeded. Winners are persisted with full lineage, and promotion into the live catalog is a deliberate manual gate rather than an automatic one. Online evolution - the loop running against your own sessions - is configurable and off by default, because it spends a model call at session end. Offline plus drafting, reviewed before promotion; not a live production self-rewrite.
A file-level audit of the open-source agent CLIs and a docs-level orientation against the closed ones. Where we lose, we say so.
Closed-source tools (Claude Code, Codex CLI) are a docs-based orientation, not a code audit. Where we lose, we say so - git auto-commit/undo belongs to opencode and aider.
One binary. Point it at a model and it does the work - calling real tools, orchestrating sub-agents, and staying inside your budget.
A Mixture-of-Providers council: N proposers, each pinned to a different provider, work in parallel, and a fenced read-only aggregator fuses one answer. Run wayland-core crucible "<task>" with --auto, --advisor, or --terminal, inside budget and daily-cap guards.
An interactive ratatui TUI, a one-shot wayland-core "prompt", or a headless --json-stream engine - from a single entry point.
Files, shell, search, web, media, scheduling - availability-gated, with a no-stubs contract: env-gated tools hide when credentials are absent.
Connect any MCP server over stdio, SSE, or streamable-HTTP - or run wayland-core mcp-serve to expose your tools to other hosts.
Fan work to parallel sub-agents with Spawn and Delegate, or run worktree-isolated swarms - up to a 100-agent Fleet, each on its own git branch.
Declarative, validated workflows - Agent, Pipeline, and Parallel stages - run as a DAG, callable as a tool or straight from the CLI.
A real 5-partition × 3-tier memory, SQLite-backed and searchable by meaning. On by default, with background decay. What you teach it survives.
Cron expressions that fire a slash command, a channel message, or a skill - from the CLI, or scheduled by the agent itself.
Drive the agent from Slack, Discord, Telegram, Signal, WhatsApp, SMS, Email, Matrix, Teams, or iMessage - one config file.
A read-only mode that studies the code and writes a structured plan before it touches a file. Approve, keep, or discard it.
Plus context compaction, named profiles with inheritance, project-context injection, computer-use on four OSes, a browser tool, an eval harness, and signed self-update.
Can an agent run unattended for hours on its own codebase - surviving crashes and injected faults without drifting or corrupting its state? We're running exactly that, as an open endurance trial.
What we don't claim: this isn't recursive self-improvement - the build is pinned and nothing rewrites itself. One clean run isn't proof of a week. A continuous week, then a month, are roadmap goals, labeled as goals. Read the method →
A workspace of focused crates. Dependencies flow strictly downward; the engine only ever sees provider-neutral types, and format conversion lives inside each provider.
| Layer | Crates | Responsibility |
|---|---|---|
| Foundation | wcore-types · wcore-compact | Provider-neutral data types; context compression |
| Core services | wcore-config · wcore-providers · wcore-tools · wcore-mcp | Config + ProviderCompat, LLM providers, built-in tools, MCP |
| Capabilities | wcore-skills · wcore-memory · wcore-sandbox · wcore-swarm · wcore-browser | Skills, memory, sandbox, swarm, browser + computer use |
| Engine | wcore-agent | Agent loop, sessions, orchestration, workflows |
| Surface | wcore-cli | CLI / TUI / JSON-stream binary |
Worktree swarm - each worker on its own git branch, process-isolated.
Fail-closed security - OS sandbox plus one CI-enforced egress gate.
npm i -g @ferroxlabs/wayland-coreCopyGrabs the prebuilt binary for your platform - no Rust or Node project required. Or run it once: npx @ferroxlabs/wayland-core "summarize the TODOs in this repo".