Wallfacer

Build software with a self-operating engineering team.

Wallfacer is a self-operating engineering platform. It orchestrates autonomous coding agents across a task board, executes them in isolated sandboxes, and gives you full oversight over every decision they make — live logs, diffs, costs, and timelines — so you stay in control while shipping at machine speed.

Quick Start

Install:

curl -fsSL https://raw.githubusercontent.com/changkun/wallfacer/main/install.sh | sh

Check prerequisites:

wallfacer doctor

Start the server:

wallfacer run

A browser window opens automatically. Add your Claude credential (OAuth token via claude setup-token, or API key from console.anthropic.com) in Settings → API Configuration. See Getting Started for the full setup walkthrough.

Why Wallfacer

• Autonomous delivery loop: backlog, refinement, implementation, testing, review, merge-ready output — end to end
• Self-development capability: wallfacer runs tasks that improve wallfacer itself, creating a compounding engineering loop
• Isolation by default: per-task containers and per-task git worktrees for safe parallelism across many concurrent tasks
• Full operator visibility: live logs, traces, timelines, diffs, usage/cost tracking, per-turn token breakdown
• Integrated development environment: built-in file explorer, host terminal, workspace management — all in the browser
• Model/runtime flexibility: Claude Code, Codex, and custom sandbox setups with per-role routing

Capability Stack

• Execution engine: isolated containers, per-task git worktrees, worker container reuse, safe parallel runs, circuit breaker, resource limits, dependency caching
• Autonomous loop: prompt refinement, implementation, testing, auto-submit, autopilot promotion, auto-retry, cost/token budgets, failure categorization
• Oversight layer: live logs, timelines, traces, diff review, usage/cost visibility, per-turn breakdown, task search, oversight summaries
• Repo operations: multi-workspace groups, branch switching, sync/rebase helpers, auto commit and push, task forking
• Development tools: file explorer with editor, interactive host terminal, prompt templates, system prompt customization
• Flexible runtime: Podman/Docker support, workspace-level AGENTS.md instructions, Claude + Codex backends, per-role sandbox routing

For a complete walkthrough of workflows and controls, see Usage Guide.
For implementation details and architecture, see Technical Internals.

Product Tour

Mission Control Board

Coordinate many agent tasks in one place, move cards across the lifecycle, and keep execution throughput high without losing control. Batch-create tasks with dependency wiring, refine prompts before execution, and let autopilot promote backlog items as capacity opens.

Oversight That Is Actually Actionable

Execution oversight

Timeline and phase detail

Inspect what happened, when it happened, and why it happened before you accept any automated output. Every task produces a structured event timeline, diff against the default branch, and AI-generated oversight summary.

Cost and Usage Visibility

Track token usage and cost by task, activity, and turn so operations stay measurable as automation scales. Per-role breakdown (implementation, testing, refinement, oversight) shows exactly where budget goes.

Roadmap

Development is organized into three parallel tracks with shared foundations. See specs/README.md for the full dependency graph and spec index.

Foundations (complete) — Sandbox backend interface, storage backend interface, container reuse, file explorer, host terminal, multi-workspace groups, Windows support.

Local Product — Desktop experience and developer workflow: epic coordination, native desktop app, file/image attachments, host mounts, file panel viewer, terminal sessions, container exec, oversight risk scoring, visual verification, live serve.

Cloud Platform — Multi-tenant hosted service: tenant filesystem, K8s sandbox backend, cloud infrastructure, multi-tenant control plane, tenant API.

Shared Design — Cross-track specs: authentication, agent abstraction, native sandboxes (Linux/macOS/Windows), overlay snapshots.

Documentation

User Manual — start here for the full reading order.

Technical Internals — start here for implementation details and architecture.

Origin Story

Wallfacer started as a practical response to a repeated workflow: write a task prompt, run an agent, inspect output, and do it again. The bottleneck was not coding speed — it was coordination and visibility across many concurrent agent tasks. A task board became the control surface.

The first version was a Go server with a minimal web UI. Tasks moved from backlog to in progress, executed in isolated containers, and landed in done when complete. Git worktrees provided branch-level isolation so many tasks could run in parallel without collisions.

Since then, Wallfacer has evolved into a self-operating engineering platform. The execution engine gained container reuse, circuit breakers, dependency caching, and multi-workspace groups. An autonomous loop handles prompt refinement, implementation, testing, auto-retry, and autopilot promotion. A full oversight layer — live logs, timelines, traces, diffs, and per-turn cost breakdown — ensures every agent decision is auditable before results are accepted.

The integrated development environment now includes a file explorer with editor, an interactive host terminal, system prompt customization, and prompt templates — all accessible from the browser. The goal is not blind autonomy; it is high-throughput engineering with clear, auditable control.

Most of Wallfacer's recent capabilities were developed by Wallfacer itself, creating a compounding loop where the system continuously improves its own engineering process.

License

See LICENSE.