convez.ai
AgenteAutomaçãoAvançado
changkun

Wallfacer

changkun/wallfacer

Plataforma de engenharia autônoma com controle granular de autonomia

Ver no GitHub
BomPluginScore · de 0 a 100

Plataforma autônoma de engenharia que integra chat, specs, tasks e código em um único fluxo de trabalho. Oferece controle total sobre o nível de autonomia dos agentes, desde exploração conversacional até execução paralela de tarefas com git worktrees isolados. Funciona localmente, sem lock-in de IDE ou dependência de cloud.

Instalação

$npx convez-ai changkun/wallfacer

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
115
Forks
14
Acompanhando
3
Saúde
57%
Último commit
há 2 semanas
Versão
v0.6.1
Issues abertas
5
Contribuidores
3

Casos de uso

  • Desenvolvimento de projetos de software com múltiplos agentes em paralelo
  • Prototipagem rápida com transição entre chat, especificações e código
  • Gerenciamento de tarefas complexas com rastreamento completo e auditoria
  • Implementação incremental com revisão de specs versionadas antes de execução

Veredito

Wallfacer é uma solução empresarial e robusta para automação de engenharia de software que vai além do chat. O design de abstração adaptativa (chat → specs → tasks → code) é genuinamente inovador, e o controle granular de autonomia resolve um problema real em sistemas de IA. Recomendado para times que precisam de coordenação de múltiplos agentes em escala.

README

A tradução para o português deste README ainda está na fila.

Wallfacer

Full autonomy when you trust it. Full control when you don't.

Go Release License Coverage Stars Last Commit

Wallfacer is an autonomous engineering platform that works across multiple levels of abstraction. Start with a conversation when you're exploring an idea. Move to specs when the shape becomes clear. Track tasks when it's time to execute. Drop into code when you need precision. Agents operate at every level, and you decide how much freedom they get.

Open source. Runs locally. No IDE lock-in. No cloud dependency. Bring your own LLM provider.

Task board
Task board: coordinate parallel agent execution
Plan mode
Plan mode: design before you build

Why Wallfacer

Every AI coding tool today pins you to one interaction mode. Chat-based tools are fast but lose structure at scale. Spec-driven tools add discipline but slow you down on day one. Task boards help you coordinate but don't understand your architecture. Wallfacer connects all of these into a continuous workflow.

Adaptive abstraction. Chat for greenfield exploration, specs for complex systems (a recursive tree of markdown specs that agents read, iterate on, break down, and dispatch as tasks), tasks for parallel execution, code for surgical edits. Move between levels as your project evolves.

Autonomy spectrum. Run the full loop autonomously (implement, test, commit, push) or step in at any point. Dial autonomy up or down per task, per spec, per project.

Spec as intermediate representation. Ideas don't go straight to code. They become structured specs that agents can reason about, iterate on, and implement against. Specs are versioned and reviewable.

Per-task git worktrees. Each task works in its own git worktree for safe parallel execution. Multiple agents work simultaneously without stepping on each other.

Operator visibility. Live logs, traces, timelines, diff review, and usage and cost tracking. A full audit trail from idea to merged code.

Self-development. Wallfacer builds Wallfacer. Most recent capabilities were developed by the system itself.

Harness flexibility. Works with Claude Code, Codex, Cursor, OpenCode, and Pi through a pluggable harness layer. Pick one per task or per agent role; not locked to any single provider.

Quick Start

Install:

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

Check prerequisites:

wallfacer doctor

Start the server:

wallfacer run                    # execs your chosen harness CLI directly as a host process

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

Other commands: wallfacer status (print or watch board state), wallfacer spec (validate or scaffold specs), and wallfacer auth (cloud sign-in). Run wallfacer <command> -help for flags.

How It Works

  1. Explore. Describe what you want to build in chat. Wallfacer helps you shape the idea.
  2. Specify. The idea becomes a structured spec. Iterate on it until the design is right.
  3. Execute. Specs break into tasks on a board. Agents implement, test, and commit in isolated git worktrees.
  4. Ship. Reviewed changes merge automatically. Auto-commit, auto-push, and auto-build when you're ready.
flowchart LR
    Idea([Idea]) --> Chat[Planning Chat]
    Chat --> Spec[Root Spec]
    Spec --> BreakDown[Break Down]
    BreakDown --> Leaves[Leaf Specs]
    Leaves --> Tasks[Dispatched Tasks]
    Tasks --> Commits([Commits])

The Autonomy Spectrum

Wallfacer lets you work at whichever abstraction level fits the problem, and move between them as the shape becomes clearer.

graph LR
    Chat[Chat<br/>exploratory] --> Spec[Spec<br/>structured design]
    Spec --> Task[Task<br/>scoped execution]
    Task --> Code[Code<br/>surgical edits]

Move left for more freedom and lower commitment; move right for more precision and higher commitment. Agents operate at every level, and autonomy dials up or down independently at each one. Specs move through a six-state lifecycle (vague to drafted to validated to complete, with stale and archived off to the side), and the planning chat exposes slash commands like /create, /validate, /break-down, and /dispatch to drive them.

Read more: The Autonomy Spectrum, Designing Specs, and Exploring Ideas.

How execution is structured

Wallfacer runs every task through a small, composable set of primitives:

  • Agents are sub-roles (impl, test, commit-msg, title, oversight, ideate), each with a harness pin (Claude, Codex, Cursor, OpenCode, or Pi), capabilities, and an optional system prompt.
  • Flows compose agents into an ordered pipeline. Built-ins are implement, brainstorm, and test-only.
  • Tasks pick a flow; the runner walks the flow's step chain.
  • Routines spawn tasks against a flow on a schedule.

User-authored agents and flows live as YAML under ~/.wallfacer/{agents,flows}/ and are edited through the sidebar Agents and Flows tabs. Clone a built-in to pin it to a harness, override its system prompt, or insert a review step, without restarting the server. Prompt refinement happens in the Plan task-mode chat (see Refinement & Ideation).

Read more: Agents & Flows.

Product Tour

Task board: managed execution

The board (shown above) coordinates many agent tasks at once. Drag cards across the lifecycle, batch-create with dependency wiring, refine prompts before execution, and let autopilot promote backlog items as capacity opens. Each task runs as a host process in its own git worktree.

Plan mode: structured design

Design before you build (shown above). The three-pane plan view gives you an explorer tree (left), a focused markdown view (center), and the planning chat (right). Break large ideas into structured specs, validate dependencies, and dispatch leaf specs to the board when the design is right.

Oversight: an actionable audit trail

Oversight summary, event timeline, and diff

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

Cost and usage visibility

Usage and cost breakdown

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

Capability Stack

  • Chat. Planning chat with slash commands and file-explorer context, the brainstorm and ideation agents, conversational drift away from or back into specs.
  • Spec. Six-state lifecycle, dependency DAG, recursive progress tracking, impact analysis, atomic dispatch and undo.
  • Task. Host-process execution, per-task git worktrees, autopilot, auto-test, auto-submit, auto-retry, circuit breakers, cost and token budgets, oversight summaries.
  • Code. File explorer with editor, integrated terminal, live logs and diff review, per-turn usage and timeline, native per-repo AGENTS.md/CLAUDE.md discovery.

Six composable sub-agent roles (each pinned to any installed harness) arrange into flows (implement, brainstorm, test-only, plus user-authored clones) that you can inspect or rewrite from the sidebar.

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): Execution backend interface, storage backend interface, file explorer, host terminal, multi-workspace groups, Windows support.

Local Product: Developer workflow. Spec coordination (document model, planning UX, drift detection), agents and flows (composable sub-agent pipelines), routine tasks (scheduled spawns), file and image attachments, host mounts, oversight risk scoring, visual verification, live serve.

Cloud Platform: Multi-tenant hosted service. Tenant filesystem, K8s execution 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 is the full reading order. Guides are grouped by what you are doing.

Get Started

GuideTopics
Getting StartedInstallation, credentials, first run
The Autonomy SpectrumMental model: chat, spec, task, code

Use Wallfacer

GuideTopics
Exploring IdeasPlanning chat, slash commands, @mentions
Designing SpecsSpec mode, focused view, dependency minimap
Agents & FlowsAgents, flows, cloning, harness pinning, recipes
Board & TasksTask board, lifecycle, dependencies, search
Refinement & IdeationPrompt refinement, brainstorm agent

Operate

GuideTopics
AutomationAutopilot, auto-test, auto-submit, auto-retry
Oversight & AnalyticsOversight summaries, costs, timeline, logs
WorkspacesWorkspace management, git integration, branches
ConfigurationSettings, env vars, harnesses, CLI, shortcuts
Circuit BreakersFault isolation, self-healing automation

Build On (Internals) is the deep reference for how the system works. Start at Technical Internals.

ReferenceTopics
ArchitectureSystem design, package map, handler organization, end-to-end walkthrough
Data & StorageData models, persistence, event sourcing, spec document model
Task LifecycleState machine, turn loop, dependencies, failure categorization
Git OperationsWorktree lifecycle, commit pipeline, branch management
API & TransportHTTP route reference, SSE, WebSocket terminal, middleware
AutomationBackground watchers, autopilot, circuit breakers, ideation
Workspaces & ConfigWorkspace manager, harness routing, templates, env config
Development SetupBuilding, testing, make targets, release workflow

Contributing? See CONTRIBUTING.md for the developer orientation, build commands, and conventions.

Origin

Wallfacer started as a task board for coordinating concurrent agent runs and grew from there: spec coordination, oversight, refinement, an integrated IDE. Most recent capabilities were developed by Wallfacer itself. See docs/origin.md for the long version.

License

MIT

Ver o original no GitHub

Bom para

Relacionados