​
Generation is commoditized. Control isn’t.

An LLM will build you a website in fifteen seconds. That part is free now, and it’s getting freer. What you still can’t get is control over what it builds — a site that is on-brand, on-strategy, and provably so, and that stays that way through every later edit, experiment, and rewrite. That gap is the product. Auxon is the control layer.

​
Auxon and sitekit

You’ll see two names throughout these docs, and they are not interchangeable. Auxon is the product. sitekit is the engine inside it.
Auxonsitekit
What it isThe product — the control layer, and the outcome it producesThe engine — the CLI and the packs it resolves
Where you meet itThe brand, this documentation, the copy dashboard, the site you end up withYour terminal, your agent’s tool calls, the files in your repo
What you install—sitekit — one binary, one skill
What gets run—sitekit run, sitekit verify, sitekit deploy
What you’d say”We build our sites with Auxon.""The agent ran sitekit verify and it failed on a banned phrase.”
The rule of thumb: if it’s being typed — by you or your agent — it’s sitekit. If it’s being described — what it does, why it holds, what you get — it’s Auxon.

​
What it refuses to do

Most of what makes Auxon useful is what it declines. It is not a website builder. It doesn’t own your design, generate your words, or make product decisions. It never calls a model as its own judgment. It is an alignment layer. It holds the brand, checks the work, and refuses what drifts. The authoring is done by your agent, working inside constraints that are enforced rather than suggested.
Auxon owns — deterministic, no modelYou and your agent own
The brand definition — voice, style, shape, valenceAuthoring the words and the design intent
The locator — exactly which span is which fieldDeciding what the page should say
The checks — structural, brand, accessibility, linksJudgment about the business
The refusal — what fails never shipsStrategy, positioning, taste
That line is why the output is trustworthy. A system that both writes the copy and grades it isn’t checking anything.

​
On-brand by construction

The central claim is narrow and testable: a page that would drift off-brand fails a check and never ships. Brand rules exist in two forms, and it matters which is which:
  • Literal. Banned phrases are a deterministic string check. If the copy says a phrase your brand doesn’t say, verify fails. No model judgment.
  • Interpretive. Register, cadence, and design intent can’t be reduced to a string scan, and Auxon doesn’t pretend otherwise. They’re enforced by being placed in front of the model every single time copy is authored — and judged by an agent reading the same written standard the author wrote from.
Around sixty checks run after every change: brand rules, required sections, mobile, accessibility, real images, link integrity. Each failure names what’s wrong and how to fix it.

Real images only

Auxon refuses invented image paths. You bring real files, search a stock library, or have the agent generate new ones — but they have to actually exist before a page can ship.
Every emitted page also carries a playbook marker recording how it was made — which voice, which style, which shape, at which pack versions. That provenance is what makes a page safely re-alignable months later, and what lets a change re-author only the pages it actually affects.

​
You talk; the agent works

Auxon is built to be operated by an AI coding agent. The CLI exists for the agent, not for you.
“Build the marketing site — editorial style, our voice.” “The pricing page header looks broken on mobile — fix it.” “We just shipped SSO. Work it into the site.”
You install two things once, then drive everything by describing outcomes.
1

Install the binary

A single self-contained executable — no Node, no source clone. See Installation.
2

Install the agent skill

sitekit init-skill teaches your agent (Claude Code, OpenCode, or any compatible harness) how to drive the engine — the commands, the conventions, and what it must never do.
3

Describe what you want

The agent reads the playbook, emits pages, runs the checks, fixes what they flag, and ships. You watch and steer.

​
The four loops

Auxon is not a generator you run once. A site has a life beyond launch day, and that’s where the real work is.
LoopYou sayThe agent runs
Build”Build the marketing site.”init → run → verify → deploy
Maintain”Fix this section / what’s drifted?”inspect → reconcile → verify --maintenance
Experiment”A/B test this headline; ship the winner.”experiment new → start → status → promote
Evolve”We repositioned — update the whole site.”brand evolve → record → reconcile --brand-delta
On experiments: Auxon reports the real numbers — rate, sample size, confidence — and flags when a test isn’t decision-grade yet. It never picks a winner for you.

​
It works on sites it didn’t build

This is the capability that makes Auxon useful on day one rather than after a migration. Most brand tooling requires you to rebuild your site inside it, which is why most of it never gets adopted. Auxon captures the brand off a live WordPress, Squarespace, Webflow, or bespoke site and binds the site to it in place. From there you can judge any page or proposed edit against that brand, keep it on-brand as it changes, and run conversion experiments on it through a single embed. No migration. No platform to move onto. See Capturing a brand.

​
The surfaces

Auxon shows up in different places depending on who’s working.
sitekit is the primary surface, designed to be driven by an agent rather than typed by hand. It ships with an operating manual — the agent skill — that teaches the agent to use it correctly.
sitekit dashboard opens a local writing surface over the copy layer: navigate to any page, edit its words, then import and verify from the same screen. Loopback-only, because it writes.It’s also a mountable component, so a host application can embed the same UI. See Editing copy.
A browser extension that lets you click any element on the live site, type the new text, review a queue, and apply. Plain text applies deterministically with no model involved.
A site Auxon builds also publishes an agent-readable surface: an llms.txt directory at the root, Schema.org structured data on every page, and a live MCP endpoint an AI client can query — answering from the same content the site shows, held to the same brand voice.So what an agent says about the business is on-brand by construction, in the same way the page is.

​
You own the result

The output is plain files on your own infrastructure. Deploy them where you like. There’s no runtime dependency on Auxon for the site to keep serving — stop using the tool and the site carries on working. The packs you capture and author are yours too: directories of JSON, CSS, and Markdown that live in your repo or your machine-local workshop, readable and editable without the tool.

​
Where to start

Install it

One command, plus the agent skill.

Build your first site

Two installs, then what to say to your agent.

How it works

The enforcement contract and the verify loop.

Capture a brand

Rip a visual identity off a URL, a screenshot, or a screen recording.

Voice packs

How a site sounds, and how that’s enforced.

Editing copy

Four ways to change the words — none needing a model.

​
Is this documentation current?

These docs describe sitekit v1.50.0, released 2026-08-09. Two ways to check that against what’s actually published: 
sitekit --version        # should print 1.50.0
Or open the latest release and compare the tag against the version named above. If the published release is newer, these pages are behind — re-run the installer to get the current build, and treat the changelog in the bundled agent skill as authoritative, since it ships in lockstep with the CLI rather than with this site.