What exactly is an AI agent?

An agent is software that takes actions — not just answers. It answers phones, sends follow-ups, pulls reports, updates your CRM, books appointments. It runs a workflow end-to-end without a human in the loop.

How is this different from ChatGPT or other AI tools?

ChatGPT is a tool you use. A governed agent is a workflow operator with a defined permission boundary. AIO focuses on what the system may do, what it should draft for review, and how the operator stays in control.

How long does it take to build an AI agent?

Most guided custom builds go live in 1–2 weeks. More complex governed workflows can take longer depending on integrations and review requirements.

Do I own the agent you build?

Yes. DIY and Guided tiers — you own it outright. Managed retainer clients own the underlying code and logic. No vendor lock-in.

What if the AI agent breaks or does something wrong?

All builds include support. Managed clients get ongoing monitoring and review of boundaries, outputs, and failures. If something misfires, it gets fixed fast.

What kinds of businesses does AIO Machine Built work with?

Startups, small businesses, and operators with repetitive workflows that need governed execution. AIO helps them choose between self-serve framework, guided custom build, and managed operator support.

THE RECEIPTS

The proof is what you'll check.

I wrote a book that says the proof is what you'll check. This is where you check it. This page grows as the system does — everything here is either public, filed with a government agency, or printed verbatim from live logs.

The System Is Real

Claim	Artifact	Where to verify
Vance is a daemon running on hardware I own	`core/daemon.py` — scheduler, heartbeat, fork dispatch, crash recovery	Private Vance repository (snapshot `8f2d91f`, 2026-07-03) — sanitized excerpts below
37+ enforcement hooks	`hooks/` directory — 40 standalone Python scripts, each with trigger, check, flag, override. Thirty-seven when the chapters were drafted; forty by the July 3 snapshot. The count grows with the incidents, which is the point.	Private Vance repository, same snapshot — the governance patterns they implement are public in TaG
Multi-model routing with escalation	`vance-router/router.py`, `budget_manager.py`, `core/escalate.py` — task classification, model selection, cost-aware routing, timeout/failure fallback with context injection	Sanitized escalation-log excerpts printed below, verbatim from the live logs
Persistent memory layer	`vance-brain/memory/` — structured memory files with frontmatter, scoped by type (user, feedback, project, reference), synced across surfaces	Private Vance repository, same snapshot
Trust and governance layer (TaG)	Open-source repository, public since 2026	github.com/AIObuilt/TaG — snapshot `b227d6c` (2026-07-03)

Cost-Aware Routing — How It Works

Vance has a routing framework that holds model capability weights and task classifications. When a task arrives, the system classifies it and routes to the cheapest capable model first — local models on my hardware when they can handle the work, then progressively more expensive cloud models. If a task times out, fails, or produces a low-quality result, the system escalates to the next tier and injects the prior context so the stronger model doesn't start cold.

That is the difference between a chatbot and an operating layer: the work moves, the context travels, and the system learns which model belongs on which job.

Escalation Logs — Sanitized Excerpts

Here are three real sequences from the live logs, printed as the system wrote them — timestamps, latencies, and model names unaltered. I trimmed empty fields and internal IDs for width. Nothing else is changed.

Exhibit 1 — Classification, then a full fallback chain. April 2, 2026. A simple status question classifies to tier 0 and stays on the local model. A minute later, an analysis task classifies to tier 1 — and four cloud providers fail before the local model catches it:

{"timestamp": "2026-04-02T22:47:01", "task_preview": "what is the current status of the system", "classified_tier": 0, "classification_reason": "short + simple keywords", "final_provider": "ollama", "fallback_used": false, "tried": ["ollama"], "latency_ms": 16056}
{"timestamp": "2026-04-02T22:48:04", "task_preview": "analyze the competitive landscape for AI agent frameworks", "classified_tier": 1, "classification_reason": "analysis/reasoning keywords", "selected_provider": "deepseek", "final_provider": "ollama", "fallback_used": true, "tried": ["deepseek", "gemini", "openai", "anthropic", "ollama"], "latency_ms": 62583}

One honest note on Exhibit 1: four cloud providers failing in the same minute almost certainly means the problem was on my end — the network, not four coincidences. The log doesn't flatter me. The “fallback chain” that day was the system routing around my own connectivity, down to the one model that didn't need the internet. That's not escalation up the ladder; it's the net catching what fell. Both are the router's job.

Exhibit 2 — Mid-conversation failover. May 13, 2026, a live operator chat session. The routed model times out at 120 seconds, the retry fails instantly, and the escalation target answers in 1.3 seconds:

{"timestamp": "2026-05-13T11:13:25Z", "session_id": "conv_6f2816e68394", "provider": "codex", "model_id": "codex", "success": false, "error": "timed out", "latency_ms": 120004}
{"timestamp": "2026-05-13T11:13:25Z", "session_id": "conv_6f2816e68394", "provider": "codex", "model_id": "codex/codex-cli", "routing_reason": "operator_policy_holly_chat", "success": false, "error": "timed out"}
{"timestamp": "2026-05-13T11:13:30Z", "session_id": "conv_6f2816e68394", "provider": "gemini", "model_id": "gemini-2.5-flash", "success": true, "latency_ms": 1269}

Same session ID on all three lines: the failures and the recovery are stitched into one conversation, and the operator waited about five seconds after the timeout was detected. What this exhibit proves is the failover — automatic, fast, mid-conversation. The context handoff itself — what the next model gets told when it takes over — happens inside the escalation engine and doesn't show in these fields. I'm telling you that plainly so this exhibit claims exactly what it proves and nothing more.

Exhibit 3 — Local fails, cloud picks up one second later. April 20, 2026, from the decision ledger:

{"ts": 1776697990.69, "actor_id": "jason", "action": "work_request", "fork": "prime", "target": "local", "model": "ollama/deepseek-r1:14b", "ok": false}
{"ts": 1776697991.65, "actor_id": "jason", "action": "work_request", "fork": "prime", "target": "openai", "model": "gpt-4o", "adapter": "openai", "ok": true}

That same fail-then-recover pair appears eight more times in the ledger that morning. The full file holds 3,825 routing decisions — 561 failures, 64 explicit fallbacks. Not every failure has a tidy recovery pair in the ledger; some tasks retried on a later cycle, and some just failed. I'm not going to dress that up. The failures are the point. The system's job isn't to never fail. It's to fail where you can see it and recover before you have to care.

Component	File	What it does
Task classifier	`vance-router/router.py`	Classifies incoming tasks against model capability weights
Budget manager	`vance-router/budget_manager.py`	Tracks spending per model tier, enforces cost thresholds
Escalation engine	`core/escalate.py`	Detects failure/timeout, promotes to next tier with context
Local orchestrator	`core/local_orchestrator.py`	Routes to local models (Ollama) when capable
Daemon scheduler	`core/daemon.py`	Runs 24/7, dispatches tasks, manages fork lifecycle

Hook Excerpts

Two of the enforcement hooks, straight from the production directory. The fabrication scanner flags unverifiable claims in agent output; the spending guard hard-blocks any action that could spend real money without a human saying yes.

block-fabrication.py

PostToolUse — scans agent output, flags claims with no evidence.

spending-guard.py

PreToolUse — hard-blocks payment/billing actions at the tool layer.

Excerpted from the production hooks directory. Internal path aliases and the internal patent-claim mapping comments trimmed; the logic is untouched.

The Business Is Real

Claim	Artifact	Where to verify
Three LLCs	AIOBuilt LLC, FindIT Publishing LLC, FindITSales LLC	North Carolina Secretary of State — public filings
Seven patent-pending claims	Provisional patent applications filed 2026	Provisionals are confidential until a non-provisional publishes — filing confirmations (receipt numbers, filing dates) available privately under NDA
FindIT deployed and running	finditsales.com — live in production	Visit the site
Pre-revenue as of this writing	Stated in Chapter 1	The book itself is the receipt

The Process Is Real

Claim	Artifact	Where to verify
Built by a non-coder directing AI	Session logs with timestamps, English-language directives, no hand-written code	Sanitized excerpts in chapters; full sanitized logs published here as they are cleared
A second non-coder operated the system independently	Co-builder's 4.5-hour session, 23 prompts, built a working prototype	Session transcript (sanitized)
The FICO fabrication happened	Session logs and the client intelligence reports it propagated into	Sanitized excerpts — the fabrication predates the scanner it inspired
The kernel panic fix worked	Session log, July 2026 — full diagnostic chain with timestamps	System logs
The silent client incident (17 days)	Email routing logs, escalation-timeout hook creation date	System logs

Timeline

Phase	Dates	What happened
First contact	November 2025	Opened a chatbot. Didn't know what a terminal was. Made twenty ugly cold-call scripts.
Learning curve	December 2025 – March 2026	Asked questions, broke things, learned what AI could and couldn't do. Built nothing of consequence.
Active building	April – July 2026	90 days of construction, 8 PM – 2 AM, while working a W-2. Built Vance, hooks, routing, FindIT, TaG.
Co-builder joins	May 2026	Second operator begins working the system independently from a different city.
Current state	July 2026	Three LLCs, seven patent-pending claims (provisional applications), deployed product, open-source governance layer, this book. Pre-revenue.

I send out what broke this month — the fire log, new receipts, what changed. Sign up if you want it.

The ramp files are at /start. When you get your first ugly win, tell me at /uglywins.