The Soul of Anvil
The Soul of Anvil
Anvil is the pattern for building and running your own workforce of AI agents: a memory that outlives every chat, a profile and guardrails for every agent, one decision surface you own, and interfaces that turn your everyday use into your agents' training. We built it to run our own company with two people and a workforce of agents. Then we noticed the pattern works for anyone.
Working with AI through chat is powerful and forgetful: every conversation starts from zero, every result disappears into a scroll-back, and nothing you do teaches the next session anything. Anvil fixes that with one loop, applied to everything worth keeping. Click a card to expand it.
Where you go in the app is a location signal — which project, which page, which scope has your attention. What you do there is an action signal — the values you type, the suggestions you accept, the defaults you override. Together they are context: your judgment, plus the exact situation it was exercised in, joined at the moment it happens.
That context accumulates in your workspace and belongs to you. Your takeoffs teach your workspace. Your corrections become next time's defaults. And when you're ready, an agent trained by exactly your own way of working takes over the repetitive parts — because it learned from you, not from a manual. This is why navigation here is easy and beautiful on purpose: a confusing interface doesn't just cost you time, it starves the learning. Every screen is built to teach two students at once — you, and your future agent.
Everything worth keeping — decisions, results, lessons — is captured, classified, and stored structured. A brand-new agent session boots from that library and is productive in minutes instead of starting from zero. You can browse it, correct it, and export it; it compounds instead of evaporating.
Every agent gets a profile: what it's for, the rules it works under, the tools it may use, everything it has ever built, and a full revision history. When an agent drifts — and long-running agents do — you don't argue with it. You check the record, fix the profile, and boot a fresh one that inherits everything.
All decisions flow through one surface you own. Agents act only inside scoped, revocable permissions; every action writes an audit trail. A misbehaving agent is a settings change, not a crisis. That's what makes it safe to hand real work to a workforce of agents.
Plans, guides, and philosophies are living documents: versioned on every change, every draft preserved. Rewind any document and watch how your own thinking developed — what you believed, what use taught you, what earned its place. This page is an instance: it's on its second revision, and the whole lineage is kept.
Every tool, page, and report an agent produces is registered the moment it ships — one library of everything built, each entry linked to the agent that made it and the place it runs. The fastest way to waste an agent workforce is to lose track of its output; here that is structurally impossible.
CSV, JSON, your own drive. Nothing is trapped in our workspace or anyone else's. The reason to stay is the context your workspace accumulates for you — not a lock on your files.
The architecture is three layers, top-down. Anvil is where the tools are developed and managed. Each tool ships standalone and does one domain well. Everything they produce flows into the platform where your business actually runs — and your use flows back up as context, which is what makes the whole thing learn.
Here is the pattern at work in our own trade: metals estimating. Mark drawings lightly in Bluebeam; Anvil WorkBench turns the marks into counts, weights, schedules, and finished estimate content — and every step you take teaches your workspace. Auto-plays; use the controls to step through.
What it is. A takeoff workbench for metals estimating — the first tool built on the pattern, and the proof it holds up under real work. Mark drawings lightly in Bluebeam; WorkBench does the rest: rollups with industry weight tables, schedule joins, a stair configurator, product attach, exports to your own storage.
How it learns. Every schedule you type, tag you assign, and default you override becomes your workspace's memory — your suggestions, your defaults, your future agent's training. Free is the workbench. Pro is the agent.
What it is. The brain the tools stand on: the memory library, the agent profiles, the decision surface, the living documents, the registry of everything built, and the context your use accumulates. Every workspace gets its own — your agents, your rules, your context. Yours is never anyone else's.
Why it matters. Tools come and go; the operating system is what makes your agent workforce compound instead of reset. It is where you develop, manage, and — when they earn it — trust your agents.
Credential Manager is next — one vault for secrets and roles, so no tool ever handles a password in the open and every workspace's boundary is enforced by design. After that: books, project management, customer relationships — each one a standalone tool, developed and managed from Anvil, feeding the same platform.
A tool joins the family only when it does six things: keeps memory that outlives sessions · profiles its agents · answers to you · keeps every draft · registers everything it builds · and runs the Learning Engine on your use.