Genius Loci — Founder & Operator
Founder & operator — agentic systems, built solo
One operator. A company that runs on agents.
Genius Loci is a one-person company operated like a small software organisation: a fleet of sixty specialised agents, one dispatch queue, local models doing the bulk of the work, frontier models spent deliberately — and a human approving every post, page, and product before it reaches the world. This page is the working record of the person who designed, built, and runs that system.
Published under the Genius Loci name while the dossier is being built out. Identity and profile links attach at launch.
The system, on one page
SuperOS is a deterministic system that runs on a home desktop and orchestrates local and frontier agents. Nothing in it freelances: work enters through one queue, is executed by whichever tier fits, and stops at a human approval gate before anything public happens.
Overarching themes
Five bodies of work, each a system rather than a project — designed once, then run, measured, and tightened continuously.
Agentic systems & orchestration
SuperOS runs sixty agents across content, commerce, and analytics. A single dispatch queue is the only write path in; every dispatched turn is a fully structured ticket with objective, context, constraints, and acceptance criteria. Executors are capacity-aware: Claude Code is the default, Codex takes small scoped tasks, and a local worker — an Ollama model given hands by the Hermes harness — does bulk work free and unlimited. Standing rule, learned from systems that “turned off silently”: a build is not done when it runs once. It is done when it is registered with the scheduler and its persistence is checked.
Local-first economics
The whole operation runs under an intentional $1/day cloud ceiling. A model router sends each task to the cheapest tier that can do it well: local models draft, NVIDIA's free API polishes, and paid frontier models handle flagship work or step in as fallback. When the local machine isn't needed for production, it is always doing something productive — queued cleanup, test-guarded fixes, and drafts — with every result reviewed before it lands.
The content engine
Six content franchises, each with a format, a lane, and a job. Calendar, scheduler, and switches were rebuilt into one system with a single source of truth: flipping a format off holds its future slots instead of posting them, flipping it on restores them if the time is still free, and the posting watcher checks the switches before every single post — an unreadable switch state posts nothing. Pieces pass truth and quality gates and a human Review Desk before they are armed to publish.
Marketing pipelines
A platform-proof funnel spine: one owned hub per franchise on geniusloci.app, one speakable call to action, email capture tagged by interest. Content comes in two classes — gated Meta-only pieces built to convert, and wide pieces everywhere carrying the hub CTA — with routing tags read by the cross-posting tool so gated work never leaks to the wrong platform. The page-job principle runs through all of it: content proves, the page converts. One page, one audience, one job.
Commerce with guardrails
Agents never publish directly. Commerce moves only through release decisions and a dedicated publishing agent; social moves only through Review Desk approvals. Sourcing is demand-first: a Demand Hunter finds real demand, a sourcing agent matches inventory or Shopify Collective supply, candidates are tested for genuine quality and competitiveness — and only winners earn the full treatment.
The Index — a smarter way to shop
The Index is the plan of record for Genius Loci commerce: a scored, evidence-backed shelf of only the best of the best, published on geniusloci.app with the methodology shown in the open. Transparency is the trust mechanism — and the marketing.
Why it is built this way
Deep product packages for single niche products are poor unit economics, so the pipeline inverts the usual store: instead of listing everything and marketing it all, demand decides what gets sourced, evidence decides what gets scored, and only what clears the bar gets a full package.
The endgame is bigger than one store: once the scoring is proven on Genius Loci's own catalog, indexing becomes a service other sellers can buy.
- Honest states over confident ones. Index Score v1 is built from knowable signals only; where demand can't be evidenced, the state is demand: unproven — not a guessed number.
- Calibrated before it counted. The score ran in shadow first, with a 20-product spot-check and a full-catalog distribution report across the 70 / 85 / 95 thresholds.
- Real imagery first. Product pages lead with real product photography; AI imagery enriches, never substitutes.
One switchboard, one truth
The most recent rebuild unified the calendar, scheduler, and content switches behind a single resolver. Every reader — scheduler, posting watcher, Review Desk, Command Deck — asks the same source, so the dashboards can never tell two different stories again.
The six franchises it runs
Each franchise has its own hub page on geniusloci.app — live since October 2026 — and exactly one job when a viewer lands there.
The Build
The daily flagship: real systems designed and built in the open, start to finish.
Agents at Work
Agents doing real jobs inside a real business, with the receipts shown.
The Breakdown
Teardowns and scores: what holds up, what doesn't, and the evidence for both.
The Stack
Tool stacks compared head to head, so builders can copy the setup that wins.
The Proof
The evidence file for the Index: scored picks, checked against reality.
The Select
The winners shelf — the small set of products that cleared the Index bar.
Milestones
The big arcs, in order. This log is a living section — new entries are appended as the system grows, and nothing here is backdated or rounded up.
The whole system, mapped
Every agent, job, and data flow in the existing stack mapped read-only before a single change was made. The orchestration design came out of that map: one point of contact at the top, structured tickets below it, and a hard rule that agents never publish directly.
Sixty agents, audited intent-first
A full tech-debt assessment of all 60 agents — intent, reality, and how each is actually invoked. The binding methodology: a valid intent that is broken gets upgraded, a valid intent never wired gets wired, the obsolete get retired, and anything unclear gets asked about, never guessed. Headline finding: a five-agent scout fleet had been running through an executor path dead for a month — exactly the capability the Demand Hunter upgrade needed.
The Index adopted as plan of record
Commerce strategy reset around demand-first sourcing and evidence-based scoring. Index Score v1 was designed from knowable signals only, calibrated in shadow against the full 65,855-product catalog, with thresholds at 70 / 85 / 95 — and an honest demand: unproven state where the evidence isn't there.
Six franchise hubs live in one evening
All six content hubs — The Build, Agents at Work, The Breakdown, The Proof, The Stack, The Select — designed from one template and published to geniusloci.app, each with its own capture mechanism and a single job: services, Stack Sheet, Scorecard, Index Drop, or the shelf.
A free polish tier in the model router
NVIDIA's free API integrated as a first-class routing tier: weaker local drafts escalate to free polish models by request type, falling back to a paid frontier model only when needed. Verified live end to end — and the one failure it surfaced (a single 60-second timeout) was priced, traced, and fixed by raising the budget on the free legs.
The local worker gets hands
The Hermes agent harness installed on the home desktop, giving the local model what chat-only inference never had: file reads and writes, a shell, and tests on the same machine as the system it works on. The free tier of the workforce became a real coder — drafting diffs that are always reviewed before anything merges.
Calendar, scheduler, switches: one system
The reconciliation build: a single source of truth for content switches, every publish path gated, hold-and-restore semantics for slots, and a tabbed Review Desk (Review · Calendar · Schedule & Switches · Assets · Products & plans). Proven live on the real calendar — slots held, then restored; a job type switched off and on through two different surfaces — with 1,835 of 1,845 tests passing.
Reserved — the log continues
Milestones are added here as they land: the dual-GPU local upgrade and resident model roster, the Demand Hunter rebuild on the revived scout fleet, the package compiler for Index winners, and commerce reactivation are all in flight.
Capability index
What the work above demonstrates, stated plainly. Depth markers reflect where the evidence sits in the systems described on this page.
Agentic systems A
- Multi-agent architecture & fleet audits CORE
- Dispatch queues & structured ticket design CORE
- Capacity-aware executor routing CORE
- Scheduler wiring & persistence checks CORE
- Failure forensics — silent-death root causes STRONG
LLM engineering B
- Task-based model routing & fallbacks CORE
- Local inference operations (Ollama) CORE
- Cost ceilings & spend auditing CORE
- Escalation design: draft → polish → flagship STRONG
- Agent harnesses (Hermes) on local hardware STRONG
Content systems C
- Franchise & format design CORE
- Calendar automation with human gates CORE
- Truth & quality gates for AI output CORE
- Asset libraries & render receipts STRONG
- Comment-gated funnel mechanics STRONG
Commerce & growth D
- Shopify operations & page systems CORE
- Demand-first sourcing pipelines CORE
- Product scoring & calibration CORE
- Hub-page conversion design STRONG
- Cross-platform repurposing rules STRONG
Verification & security E
- Test-driven acceptance (1,845-test suite) CORE
- Live proofs before claims CORE
- Read-only audits & exposure checks STRONG
- Secret redaction & peer allowlists STRONG
- Approval-gated publishing, end to end CORE
Ways of working F
- Documented systems over tribal knowledge CORE
- Intent-first assessment, never guess CORE
- Honest states in data and in reporting CORE
- One operator, end-to-end ownership CORE
- Build in public, with receipts STRONG
Operating principles
The rules the system runs by. Each one was earned from a real failure or a real save.
Agents propose; humans approve
No agent posts, publishes, or sells anything on its own. Commerce clears release decisions, social clears the Review Desk, and the operator holds every final key.
One source of truth
If two dashboards disagree, the system is broken — not the operator confused. Shared state is resolved once, in one place, and every surface reads from it.
Done means scheduled
Running once proves a thing can work; it doesn't make it live. A build closes only when its invocation is declared, its scheduler registration is shown, and its persistence is checked.
Spend frontier like money
Local and free tiers do the bulk of the work under a hard daily ceiling. Paid frontier calls are a budget line, reserved for the work only they can do.
Systems I work with
Not partners — platforms, grouped by the job they do. Developer keys, APIs, and daily production use across the systems this operation runs on. The last row is the honest exception: tools on the evaluation list, not yet in production.