도깨비 방망이
한국어
Request

Request console for ordinary software work

Tell AW what you want built.

AW turns software requests into specs, code changes, verification evidence, and reviewable delivery artifacts.

Start a requestSee team workflow
Start
Natural-language request
Gate
Approve scope before work
Receive
Preview, report, PR

Request Console

Request software without opening an IDE.

Approval needed
Customer portal for service requests
  1. Spec
  2. Building
  3. Verifying
  4. Approval
  5. Done
Onboarding checklist for new customersAwaiting approval
Stripe invoice payment flowDone

My Requests

Internet not workingIn progress
Billing questionAwaiting response
Login issueResolved
PreviewReportPR

Other AI harnesses feel heavy?Dokkaebi harness ships autonomously.

Architecture · 7 steps

How a request becomes a PR

  1. 1Request

    A PM or stakeholder writes one natural-language line. Nobody touches code yet.

  2. 2Spec proposal

    Wand drafts spec.md. A human approves once, and the real work starts.

  3. 3Agent dispatch

    Claude / Codex / Gemini / Ollama — Wand picks the right model per task and calls it.

  4. 4Review / fix loop

    A second agent reviews; a fixer patches. The loop repeats with no human in the middle until it passes.

  5. 5AOP gates

    Static analysis across 10 dimensions (security, clean architecture, observability...). Security HIGH cannot be waived.

  6. 6Ledger

    Every decision and reason is appended to a JSONL ledger. Who, why, when — auditable later.

  7. 7PR

    Wand opens a GitHub PR with the trust report attached. A human still merges and deploys.

Drop-in · no rewiring

Where Wand fits in your existing workflow

  1. PM
  2. Wand
  3. GitHub PR
  4. Your CI
  5. Code review
  6. merge
  7. deploy

You don't have to switch tools. GitHub Actions, Slack reviews, your existing deploy pipeline — keep all of it. Wand only takes the request → PR step. The rest of your day looks the same.

vs Claude Code · Codex · Cursor · Aider

How Wand compares to other AI coding tools

CapabilityWandClaude CodeCodexCursorAider
Spec gate (one human approval)✓✗✗✗✗
Ledger (every decision + reason)✓✗✗✗✗
Fix loop (auto-iterate)✓partialpartial✗partial
AOP gates (10 dimensions)✓✗✗✗✗
Parallel agents✓✗✗✗✗
Trust report (attached to PR)✓✗✗✗✗
Multi-day autonomous runs✓✗✗✗✗

"partial" = the capability exists but is shallow (no spec gate, no ledger, no AOP).

What the operator sees

While Wand is working

homepage.rs · diff
@@ push_developer_hero(&mut body, language);
+ push_d1_architecture(&mut body, language);
+ push_d9_workflow_fit(&mut body, language);
+ push_d7_comparison(&mut body, language);
+ push_d2_workspace_mock(&mut body, language);
+ push_d8_adoption_steps(&mut body, language);
  push_hero_and_request_console(&mut body, copy);
$ dokkaebi reconcile
▸ phase: implement
  agent: codex (gpt-5.4:xhigh)
  files changed: 3 · tests: 0 → 4 passing
▸ phase: review-loop
  reviewer: claude-cli → 2 findings (auto-fix)
  fixer: codex → patched ✓
▸ phase: aop-weave
  security: ✓  clean-arch: ✓  observability: ✓
▸ PR opened: #312

This is what the operator sees while Wand is doing the work. A human only steps in when a gate turns red.

From laptop to company-wide

Adopt at your own pace — 5 minutes, 1 day, or 1 week

5 minutesSolo / side projects
pip install dokkaebi
dokkaebi init my-app
dokkaebi intake "build me a customer portal"
dokkaebi reconcile

CLI only. No GitHub required. Runs straight on your laptop. The first PR candidate lands in your hand in 5–10 minutes.

1 dayTeam / startup
dokkaebi init --github-repo your-org/your-app
dokkaebi intake "..." --approver @teamlead

Plugs straight into your GitHub PR flow. Pick your approval channel — Telegram, Slack, or GitHub Review. Your existing code-review flow stays exactly the same.

1 weekCompany / multi-repo
.github/workflows/dokkaebi-gates.yml
.harness/CONSTITUTION.md
dokkaebi cron --start
dokkaebi skills scan

Add AOP gates to CI. Enforce company policy (allowlists, token budgets). Multi-repo, multi-agent, permissioned — all on.

Senior-dev questions, answered straight

The router picks the model. T0 does the dumb work; expensive models only run when it actually matters.

  • Every task maps to one of four tiers — T0 (algorithm, no LLM), T1 (local Ollama), T2 (light cloud/CLI), T4 (deep reasoning).
  • Per-model prices are baked into the code; every call carries a USD estimate. Local models cost zero.
  • CostGovernor uses a reserve → commit/release 3-step transaction to gate LLM calls. GovernedLLMClient wraps every non-stub backend — no bypass. Exceeding the cap raises BudgetExceededError, a hard stop.
  • All usage written to append-only JSONL ledgers. `dokkaebi tokens --summary / --hotspots / cost` for after-the-fact accounting.

Why it matters Cursor / Claude Code stick to one model. Wand routes per task and reserves budget before each call — "why is this month $400?" gets blocked upfront, not after.

Honest about: Provider price changes need a manual update. CLI backends (Claude/Codex CLI) expose only estimates — exact tokens stay private.

What Wand won't do — invent novel algorithms, exercise design taste, or close problems where evidence won't converge.

  • Fix-retry capped per quality preset (basic / medium / advanced / premium). Exceeding raises max_fix_retries_exceeded → failed. Escalate instead of looping.
  • Review-loop has a round cap. If reviewer ↔ fixer can't agree within it, it stops.
  • Reverse-clone / site-clone work but don't guarantee pixel-perfect. JS-heavy SPAs expose the crawl engine's limits.
  • Local Ollama on HDD has a ~2-minute cold start and can time out on large prompts. Truly fast inference still needs cloud T2/T4.
  • 'Security HIGH = no waiver' (CONSTITUTION + RG-12) means specs with HIGH security findings cannot merge. That's an intentional failure mode.

Why it matters Other tools handle "can't" with silence. Wand caps retries, rounds, and budgets explicitly, and the ledger holds evidence right where it stopped. Something to debug.

Honest about: Post-stop escalation UX is rough. Humans often have to read the ledger / failure record directly.

Budget, approval gates, model choice, sandbox — every dial. Lock them all and you get dry-run.

  • One quality preset (basic / medium / advanced / premium) sets fix retries, review-loop on/off, round caps, and review tier together.
  • Twenty release gates (RG-01..RG-20). Highlights: RG-02 (zero HIGH/CRITICAL AOP gaps), RG-04 (no unresolved Intent-Lock), RG-05 (100% tests), RG-12 (zero HIGH security), RG-14 (GitHub approval).
  • Intent-Lock — meaning changes require a human decision. Canonical docs (SPEC.md / ROADMAP.md / CONSTITUTION.md) are proposal_only.
  • SecuritySandbox + StageToolRouter — tools available per stage. `rm -rf /`, `curl | bash`, etc. are deny-listed; path containment is enforced.
  • Self-host with five backends. An all-local Ollama setup is legal. GitHub approval adapter requires a logged approval event before merge.

Why it matters Claude Code / Cursor stop at allow/deny prompts. Wand offers four axes — code, machine, budget, human-approval.

Honest about: More dials, more learning curve. The default (medium) is reasonable but expect a week of tracing which gate blocks what.

Aspects, tools, adapters — inherit one abstract class and you're in.

  • Aspect: extend AspectRunner → register with AOPEngine.register_aspect(). Eleven aspects ship by default (security / clean_arch / observability / resilience / api_contract / test_quality / performance / llm_security, etc.) — add your own.
  • Tool: ToolRegistry.register(ToolDef) — JSON-schema based, plugs into P0/P1 registries. StageToolRouter controls per-stage exposure automatically.
  • WorkerAdapter: implement the interface to plug in your own backend (in-house model, other CLI agent). LLM / ClaudeCode / CodexCLI / QA / DryRun ship today.
  • LLM backend: LLMClient base class. Adding a sixth backend is one class.
  • Skills: install requires scan + human approval (`skills scan / approve / install / revoke`). Routing overrides supported.

Why it matters Cursor gives you a model menu; Aider gives you a backend menu. Wand exposes four extension points — validation rules (aspect), tools, backends (adapter), and routing.

Honest about: Plugin-SDK docs are scattered across spec and code. A polished outside-developer guide is still thin — expect to read source and extend.

MIT licensed. All state is plain JSONL. Want to leave? Take the .harness folder and go.

  • License: declared in pyproject.toml — MIT. Commercial use, forks, redistribution all allowed.
  • Self-host: every step can run locally — Ollama T1/T2 + CLI agent T4. Works without cloud API keys (with a speed trade-off).
  • Data portability: every meaningful piece of state lives under .harness/ as plain text. decisions / actions / tokens ledgers are append-only JSONL with JSON Schema published under schemas/. Atomic write (temp → fsync → os.replace) keeps it consistent.
  • Audit trail: every decision / action carries summary_human — readable with `cat` / `jq`. `dokkaebi why / timeline / explain` works on top of that plain text.
  • No lock-in: code Wand writes is just code. No bespoke runtime dependency. The agent-to-agent protocol DCL/1 is open as well.

Why it matters Cursor / Devin and friends default to SaaS lock-in. Wand publishes the code, the state format, and the protocol — "if Wand's company folds tomorrow, my repo still runs" is real.

Honest about: MIT doesn't mean hosting is free. Self-hosting costs (machines / model APIs) are on you. Parts of the OQ platform integration live in private repos — open-core.

How AW proves it can build

AW earns trust by building — and fixing itself

AW builds real tools from a 100-level capability ladder. Every wall it hits exposes a defect in its own harness — AW roots out the cause, ships the fix as a reviewable spec, and re-climbs. The wall then moves one layer downstream.

  1. Climb
  2. Hit a wall
  3. Root-cause
  4. Fix the harness
  5. Re-climb
  6. Wall moves downstream

This is dogfooding as a gate: AW is judged not by a demo, but by whether it can build the next tool the last one couldn't. L005 was the ladder's first clean full-green — given only acceptance criteria, AW self-converged a cardinality tool to a HyperLogLog hybrid with no human hint.

What AW can already do

1

Self-evolving harness

AW hits a wall, diagnoses the defect in its own engine, ships the fix as a reviewable spec, and re-climbs. A convergence chain of 100+ specs is this loop in action — the harness that builds also repairs itself.

2

Reverse-clone pipeline

Point AW at a URL: it crawls, extracts a typed IR, and deterministically emits a Next.js frontend, a Bun/Elysia backend, a typed monorepo, and Cloud Run deploy artifacts — graded against a measured fidelity SLA.

3

Evidence-grounded acceptance

AW doesn't trust a green build. It drives the delivered tool with behavioral probes and execution evidence, catching capabilities that compile and pass tests yet don't actually work.

4

Progressive-determinism codegen

A growing deterministic core emits byte-identical output with no LLM, wrapped by a reproducible LLM tail — so more of what AW ships is verifiable by construction, not by hope.

What's next

Where AW is heading

Compound returns from a self-improving builder.

Wand is building Wand.

This very site is the proof.

The page you're reading, the carousel, the cards, the numbers — all of it was written by Wand. The operator only said "build a site like this." Wand wrote the code, the tests, and shipped the deploy.

Yesterday's Wand builds today's Wand.

Each of the 73 specs becomes a tool for the next spec. When Wand ships a new capability, it uses that capability to ship the next, bigger one. A human only has to set direction.

What you receive gets better every week.

Order today and "this week's Wand" ships it. Order again next month and "a month-better Wand" ships more, for less. Freelancers don't compound like this.

Not locked into Claude or Codex.

Wand routes each step to the best-fit backend. If one vendor raises prices, breaks, or sunsets a model — we swap. Your delivery doesn't stop.

Most jobs run through 2 to 3 backends concurrently. Single-vendor lock-in is not our risk profile.

Three AW-only reasons to care

Three reasons AW is different

1

Request to Sub-spec Gate

Broad requests become reviewable, independently testable slices before implementation begins.

2

Delivery Ledger + Evidence

Decisions, actions, gates, tests, screenshots, traces, costs, and failure reasons stay attached to the run.

3

Review/Fix Loop + AOP Gates

Agent output passes through reviewer/fixer loops and quality gates before PR handoff.

From request to reviewable delivery

AW end-to-end delivery process

  1. Request
  2. Spec
  3. Sub-spec Gate
  4. Tasks
  5. Agent Implementation
  6. Tests/AOP
  7. Review/Fix
  8. Evidence/Ledger
  9. Preview/PR/Deploy

For experts who need depth

Open the workspace when you need depth.

AW Workspace exposes files, specs, diffs, gates, logs, verification, and agent progress for teams that need to inspect the run.

Ask AW to adjust scope, inspect evidence, or continue the run...

01-overview.md

Customer Portal - Overview

Provide customers a place to create, track, and manage service requests with role-aware access.

[tests] 128 passed[aop] 2 warnings[review] awaiting handoff

Delivery harness for development teams

Plug AW into your software delivery process.

AW integrates with repositories, CI, reviews, agents, tests, evidence, and PR workflows. It can wrap Claude Code, Codex, ScreenPlay, and custom automation instead of forcing one coding agent to become your whole process.

For non-developers

Ask for software, track status, preview results, and approve scope without opening an IDE.

Start from a request

For professional teams

Use AW as a governed delivery harness around existing repos, agents, checks, reviews, and PR handoff.

Discuss team integration

Category boundary

Antigravity is an AI IDE. AW is a request console plus delivery harness with scope gates, ledger evidence, and review loops.