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, ~75 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 the platform's strongest sandbox - bubblewrap, sandbox-exec, AppContainer - and fails closed when none is available. 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. Winners seed your library with full lineage - it gets sharper the more it runs. (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".