# The Vibe Axis

*A building-block substrate for LLM-run businesses*

---

## The axis we didn't know we were building

When we built the first nine Vibe Studio Apps, we thought we were solving a distribution problem — getting LLM output out of the chat window and into a place where someone could click, edit, share. That's the surface of the story. The deeper story is about an axis we accidentally tripped over and that turns out to enable something much larger.

The axis is this: **the URL is the artifact, and the LLM is the formatter.**

That's two moves stacked. The first ("the URL is the artifact") gets all the press — the hash-as-payload trick, the no-server distribution, the artifact that travels. The second ("the LLM is the formatter") is the quieter, more consequential one. Because once the LLM chooses the artifact shape per task — *this is a memo, this is a sequence diagram, this is a workbook, this is an invoice* — every artifact-design activity that used to consume human time in business operations stops being a human activity.

Form design. Report templates. Schema engineering. "What deliverable should this be?" Picking the file format. Picking the chart type. Choosing whether something is a doc, a sheet, a graph, or a slide deck. These are all *formatting decisions*. They're judgement calls about how to package information for a given context. They're also the bulk of what knowledge workers actually do — and the bulk of what enterprise software exists to mediate.

When the LLM picks the artifact at emission time, you don't need software that mediates the form choice. You don't need a "report builder" tool. You don't need a "dashboard designer" tool. You don't need a "form generator" tool. The decision happens at the moment of speech, between the user's intent and the model's output. The studio renders whatever the model chose. The user sees the result. They don't have to know what kind of thing it is.

This is the unique axis. It's not "URLs are nice." It's that **the LLM picks the shape, the substrate renders the shape, the human consumes the result** — without any of the intermediate apparatus that the SaaS industry sells.

## What gets displaced

Look at what dies along this axis once it's working:

- **Report builders.** When the LLM is the report builder, you don't need 50 templates and a drag-drop UI. You need a substrate that renders whatever JSON the model emits.
- **Dashboard designers.** Same logic. The LLM picks the right viz for the question; the studio renders it.
- **Form designers.** The model knows what fields a "support ticket" or "purchase order" needs, depending on context. It emits the form *and* the data together.
- **Pre-fab spreadsheet templates.** Why pick one of 200 templates when the model can generate exactly the workbook you need, with the exact formulas?
- **The wrapper SaaS layer.** Most B2B SaaS is "a database + opinionated forms + reports built on top." If the LLM handles the formatting and the URL handles the distribution, the database-plus-forms layer collapses into "whatever JSON shape the model emits."

What survives are two things: **the data plane** (where money, identity, and state-of-record actually live — banks, payment processors, regulators, contracts) and **the substrate** (the rendering studios). Almost everything between is now obsolete because the LLM crosses it.

This is the field-flattening insight. Most operational software is connective tissue between humans and the data plane — connective tissue made of forms, reports, dashboards, templates. When the LLM is the connective tissue, the rest dissolves.

## Building blocks, not products

This reframes what we should be building. Not products. **Building blocks for LLM agents.**

Each Vibe Studio is a building block: it renders one *kind* of artifact and exposes one *skill* that teaches the LLM how to emit that kind. The LLM is the integrator. The user is the operator.

The right unit of progress, then, is *adding a new kind of artifact the substrate can render*. Not adding features to existing studios. Not building a "platform." Building **more shapes**, each with the same minimal contract:

1. A studio (single HTML file, hosted statically).
2. A schema (JSON, ~50 lines).
3. A skill (Markdown + a 30-line encoder).

Three artifacts. No backend. No accounts. The LLM does the rest.

That's the substrate's promise: every new artifact you can teach the LLM to emit, your business can now produce on demand, deliver as a URL, edit in a browser, archive as a bookmark, audit by inspecting the hash. The marginal cost of a new business deliverable, end-to-end, goes from *building a feature in a product* to *writing a 50-line schema and a 30-line encoder.*

## The roadmap: from generic studios to operational backbones

The ten studios we have today are *generic*. They handle any Mermaid diagram, any Markdown, any workbook. They're the foundation kit. The next layers are specific:

**Layer 1: generic surfaces (shipped).** Flow, KG, Doc, XLS, Python, HTML, 3D, Node, MindMap, Media. These render any artifact of a given general shape. They are the substrate's "primitives."

**Layer 2: operational artifacts (next).** Invoice, Receipt, Quote, Statement-of-Work, Purchase Order, Expense, Pay Stub, Subscription, Pricing Page, Order Confirmation. Each one is a narrow JSON schema with one studio and one skill. The LLM emits exactly the right artifact for the conversation it's in — *"bill Acme for the kickoff"* → invoice URL.

**Layer 3: collaboration artifacts.** Support Ticket, Bug Report, Incident Report, Decision Record (ADR), RFC, Meeting Minutes, OKR sheet, Project Brief, Status Update. These get used a hundred times a week in any operating company, and they're each fifty lines of schema and a UX that mirrors the workflow around them.

**Layer 4: HR + legal artifacts.** Offer Letter, Reference Check, NDA, Contractor Agreement, Policy Doc, Employee Handbook Section, Performance Review form. Same pattern. The LLM emits a complete, working document; the user edits; the URL circulates.

**Layer 5: finance + accounting artifacts.** Balance Sheet, P&L, Cashflow Statement, Audit Trail Snapshot, Budget vs. Actuals report, AR Aging report. Connected to the *data plane* (the accounting system) via read-only fetches; the studio renders; the LLM writes the commentary.

**Layer 6: customer-facing artifacts.** Onboarding checklist, Status page snapshot, Outage post-mortem, Product changelog, Roadmap teaser, Customer success plan, Pricing comparison.

That's roughly 60 specific studios across six layers. Each one is hours, not weeks. Each one collapses an entire category of operational software into a substrate-rendered URL.

Add a seventh layer and we're not just running a business — we're running *most departments* of a business — on URLs:

**Layer 7: industry-specific artifacts.** Clinical trial protocol summary, manufacturing batch record, construction RFI, legal brief, real-estate disclosure pack. The substrate doesn't care about the domain. The schema and the LLM do.

## What it takes to "run a business" on this

A business runs on three things: **deliverables** (what gets handed to people), **decisions** (what gets decided and recorded), and **state-of-record** (where the truth lives). Vibe Studio Apps own the first. They share the second with email, Slack, and notes. They never own the third — and they shouldn't.

So the picture is:

- An LLM agent receives an input (an email, a Slack message, a question, a calendar trigger).
- The agent decides what artifact to produce (memo, diagram, workbook, invoice, ticket, brief).
- It emits a Vibe URL of that artifact.
- The URL is sent through the existing channel (email, Slack, calendar, a notes app).
- A human (or another agent) opens the URL, edits, approves, forwards.
- State-of-record (accounting system, CRM, regulatory database) gets updated via existing APIs — but only the *atoms* that need persistence: invoice number, ledger entry, ticket status. Everything else lives in URLs that circulate.

This is what "LLM agent runs a business" looks like in practice. Not a giant autonomous loop replacing humans. A substrate where every operational deliverable is one prompt away from being a URL, and humans stay in the loop by clicking, editing, approving, forwarding.

## Minimal viable architectures

The phrase "minimal viable architecture" matters here. We're not building toward an enterprise stack. We're building toward the **smallest possible scaffolding that still works end-to-end**.

For each new vibe studio, the minimal viable architecture is:

- One static HTML file (the studio)
- One Markdown file + 30-line script (the skill)
- One JSON schema (~50 lines)
- Static hosting (Netlify, GitHub Pages, anywhere)

That's it. No backend. No database. No auth. No tenancy model. No billing. No webhooks. No infra to scale. The studio doesn't know who is using it; the skill doesn't know what user; the URL doesn't know which workspace.

This is deliberately monastic. Every piece of infrastructure you don't have is a piece you don't have to scale, secure, audit, decommission, or upgrade. The cost of *adding* a studio is hours; the cost of *keeping* a studio is zero.

When a workflow needs persistence — accounts receivable, ticket history, payroll — the substrate hands the persistent atoms to the data plane (QuickBooks, Stripe, Zendesk, Workday) via existing APIs. The substrate stays thin. The persistent system stays the persistent system. Nothing duplicates.

This is what "minimal viable architectures, flattening the field of business operations" means concretely: **the LLM and the URL collapse the middle of the stack, leaving only the substrate (thin) and the data plane (specialised).** The middleware industry — the layer of B2B SaaS that exists to mediate forms, reports, dashboards, approvals, templates — has nothing left to mediate.

## Controls via discussion: the self-extending substrate

The last move is the strangest and the most consequential. The substrate is *built to extend itself by conversation*.

Picture this: you're running a business through Vibe Studio Apps. The LLM hands you invoices, tickets, briefs, statements every day. One Tuesday, a finance reviewer says, *"I want a one-page commission statement we can send to reps at month-end."*

There's no commission-statement studio. There never was. But the recipe is well-defined: a schema, a studio, a skill. The LLM can author all three. The LLM can ship a new studio to a new path on the existing static host — in minutes, end-to-end, by writing the same three files we wrote for the existing ten.

The substrate, in other words, has the property that **the LLM can extend the substrate itself, through conversation.** New artifact types don't require a product roadmap. They require a prompt. The acceptance criteria are: *does the studio render the schema? Does the skill emit a working URL? Does the example look right?* The user adjudicates by clicking the link.

This is what the user means by *"different controls via discussion with a system that can enable its own change."* The substrate doesn't have controls in the traditional sense — settings panels, permission models, config files. Its controls are: *the conversation that produces new artifacts and the conversation that produces new artifact types*. Change the conversation, change the substrate. The substrate is a function of the prompts that build it.

This is the loop that gets us out of the SaaS attractor. Most software treats the user-product interface as a fixed surface — features the vendor decides, users adopt. The Vibe substrate treats the user-product interface as a *negotiable* surface — features the user articulates, the LLM ships. The interface becomes language.

## The two-year picture

If the pattern compounds the way we think it will, the substrate in two years looks like:

- **50 to 100 vibe studios**, each one a narrow artifact type, each one one HTML file.
- **A skill registry** that any LLM can install: tell the model what business it's running, and it picks up the relevant subset (an SMB? a clinical trial? a building project? a law firm?).
- **A small number of data-plane adapters**: read-only fetches into QuickBooks, Stripe, Linear, GitHub, Workday, regulators, banks — just enough to ground the artifacts in persistent truth.
- **An emergent extension culture**: companies forking studios, adding schemas, sharing them, the way teams now fork Notion templates or Airtable bases.

That picture doesn't require us to build a platform. It requires us to keep building blocks. Every studio is one more shape the LLM can emit. Every shape is one more category of operational software that collapses into a URL.

The unique axis — the URL is the artifact, the LLM is the formatter, the substrate is built to extend itself by conversation — gives us a roadmap that doesn't run out. As long as there are deliverables a business produces, there's a vibe studio waiting to be written. The substrate stays minimal. The LLM does the work. The business runs on URLs.

That's the move.

---

*Atomic 47 Labs · Vibe Studio Apps · 2026-06-24*
*[atomic47-studios.netlify.app](https://atomic47-studios.netlify.app)*