An intelligence that does real work where a team already talks.
Quinn Console resolves to five words and three verbs: the everything app, think it, build it, deploy it. A person has an idea where they already talk, builds it with AI, and ships it to the world. Two choices separate Quinn from a convenience layer over a model. It does not just act, it checks its own work against a quality bar before handing anything back. And the brain is the customer's, held for them and theirs to take.
- Primary surface
- The messenger the team already uses. Discord live; Slack, Teams, WhatsApp on the roadmap.
- Unit of value
- An outcome the intelligence plans, does, and verifies, not a static workflow.
- Stage
- Live, with 10 paying teams and unprompted referral pull.
Think it, build it, deploy it.
The three verbs are not marketing structure. They are the actual sequence of what a user does, and each verb corresponds to a distinct layer of the product. Depth increases as a user descends: THINK is for everyone and is where almost everyone arrives; DEPLOY is where a person already leaning in feels the ground open into something larger than a tool.
| Verb | What the user does | What the product provides |
|---|---|---|
| Think it | Has an idea, in plain language, where they already talk | A conversational surface inside the messenger, and the brain that remembers context and prior work |
| Build it | Shapes and modifies a real thing with AI as a capable teammate | The plan-act-verify execution loop, connected services, and the workspace repo where the work lands |
| Deploy it | Ships the built thing to the world, or to their people | Publish-and-earn through the marketplace, or build-once-deploy-many across a group or client book |
Build once, deploy many. An action is a portable unit that works across accounts. A solo builder meets that mechanic as share what I made. An operator who carries a book of clients meets the same mechanic as roll this out to everyone I serve. One idea, two doors, both inside DEPLOY, and it is an offer the static-workflow incumbents cannot easily write.
Messenger-native by design.
Quinn's premise is that the surface is the messenger the person already uses, so distribution is not a new install. The customer does not change tools, learn a new interface, or context-switch. They talk to Quinn in the thread where they already work.
| Design choice | Consequence |
|---|---|
| Meet the user where they already are | No new-app adoption tax; the surface is a place the user already lives |
| Conversation is the interface | No form-and-menu learning curve; the user states intent in plain language |
| The thread is the workspace | Context, history, and collaborators are already present |
| The messenger carries the social graph | Referral and community formation happen in the same place work happens |
Surface coverage
Delivered through a universal messenger harness: first-class native adapters for the major platforms, plus a universal connector for the long tail. The messenger is the surface, but it is not the source of truth. Every inbound data point is source-tagged at the messenger-contract layer, so the same brain is reachable from any surface and the customer's context is never trapped in one channel.
| Surface | Status | Role |
|---|---|---|
| Discord | Live | The current front door; where the 10 paying teams work today |
| Web (quinn.lightbrands.ai) | Live | Dashboard, workspace view, onboarding, and a first-party chat surface |
| Slack | Roadmap | Enterprise and team distribution, via a native adapter |
| Microsoft Teams | Roadmap | Enterprise distribution, via a native adapter |
| Roadmap | Consumer and international reach, the largest messenger base | |
| Universal connector | Roadmap | The long tail of messengers via a single connector contract |
It does the work, and it checks it.
The tools people already know sell static workflows that break silently and cost more as they scale. Quinn carries judgment inside the work itself: it plans, it acts, and it verifies against a quality bar before it hands anything back. The verification moment is the product's most load-bearing and least-visible feature.
| Property | Static workflow | Quinn |
|---|---|---|
| Failure surfacing | Silent; discovered downstream | Caught at the verification gate before handoff |
| Response to drift | Breaks when reality diverges from the script | Re-plans; judgment absorbs the drift |
| Trust basis | The user must inspect every output | The gate result travels with the output |
| Reusability of a result | None; every run is fresh | A gate-verified result is provably correct and can be safely reused |
The verification gate is also the foundation the cache is built on. A cache that replayed unverified results would serve matching but possibly wrong work. Because Quinn verifies before it serves, a reused result is a proven-correct result, not merely a matching one. The gate is the quality bar for the individual user and the correctness guarantee that makes cross-tenant reuse safe.
Actions: outcomes you install in one tap.
Around Quinn sits a marketplace of actions. An action is an outcome a customer installs in one tap and runs on their own connected services. It is where most of the visible product lives, and it is the supply side of the flywheel.
| Attribute | Detail |
|---|---|
| Definition | A portable, named unit of work that produces an outcome |
| Authoring | Built by a community member, or Light Brands, in the open workspace format |
| Installation | One tap; the action then runs on the installer's own connected services |
| Portability | Works across accounts; the same action runs for any customer who installs it |
| Economics | The author earns every time anyone runs it, and the buyer's cost falls from the same event |
Build once, deploy many, three motions
The same action serves three motions without modification. This is the pattern that made prior platform standards durable: the deepest moat of a developer platform is rarely the core runtime, it is the library ecosystem that accretes on top of it. The actions marketplace is Quinn's library layer, portable by construction.
Solo builder
Community leader
Operator or agency
It runs on the best model.
Quinn runs on the best model available at any moment. When the frontier improves, the customer improves. When the lead changes hands between model vendors, it changes underneath the customer without them feeling a thing. Provider-agnostic execution is delivered by a stateless, cost-optimized harness that separates what work is to be done from which model does it.
| Property | Detail |
|---|---|
| Provider coupling | None at the format layer; the model is selected at execution time |
| Model selection | The best available model for the task, at the moment of the run |
| Frontier capture | Frontier improvements accrue to the customer automatically |
| Vendor-lead changes | Absorbed underneath the customer, with no migration event |
| Cost posture | The harness routes to the economical option that still meets the quality bar |
If the workspace format is portable and the execution is provider-agnostic, the model vendors become suppliers rather than competitors. Quinn sits above the churn of which model or which messenger is winning that year. This is the structural precondition for the standard-layer position: a standard captures value precisely because it is not tied to the fortunes of any single supplier beneath it.
The workspace is yours to take.
The brain is the customer's. Their memory, their connected services, and the way Quinn has learned to work for them travel with them across the tools and surfaces they use. This is literal, not a slogan: the workspace is a GitHub repository provisioned exclusively for that customer, and the customer can clone it and leave with everything, at will.
| Element | Detail |
|---|---|
| Where the workspace lives | A GitHub repository provisioned and held exclusively for that customer |
| What it contains | The customer's memory, context, connected-service configuration, and authored actions |
| Export | The customer can clone the repo and take all of it at any time |
| The honest promise | Exit, not day-one legal ownership. Light Brands holds the repo; the customer can leave with everything |
| Operator case | When an operator sets Quinn up for a client, the same rule holds for the client's workspace |
A thing a customer can always walk away with is a different promise than software that holds them hostage. The claim is falsifiable in five minutes, which is exactly why it makes every other claim in the product more credible: a customer who confirms they can clone and walk trusts the rest. The same artifact that lets one customer leave is the artifact that, published as a named and versioned open format, lets anyone build a runtime that is not Quinn.
Ten layers that compose into the everything app.
The product is a stack of layers, each independently defensible, which compose into the everything app. Quinn is not a single feature a vendor could copy; it is a set of layers whose defensibility comes from how they fit together.
| Layer | What it does | Status |
|---|---|---|
| Surface | Meets the user where they already talk; the web front door | Discord + web live; more on roadmap |
| Interaction | Turns plain-language intent into planned work | Live |
| Execution | Does the work and checks it against a quality bar | Live |
| Model | Runs on the best model at any moment; cost-optimized | Live |
| Reach | Acts on the customer's own tools and data | Live |
| Extensibility | Install-in-one-tap outcomes; the supply side | Live |
| Ownership | The customer's brain, held for them, theirs to take | Live |
| Deflation | Work computed once, replayed near-free; provenance on every reuse | Shipped (PR #200); reuse curve in measurement |
| Economy | Build, refer, seed, earn-to-use | Build and refer designed; seeder staged |
| Standard | Named, versioned, conformance-tested open format | Strategy locked; spec publication is a use-of-funds line |
The reading of the stack: the verification gate makes the cache safe, the cache makes the economy positive-sum, the exportable repo makes the format credible, and the format makes the whole thing a standard rather than an app.
One motion, from idea to standard.
A user states an idea in their messenger; the intelligence plans, acts on the user's own services, and verifies the result; the work lands in a workspace repo that is the user's to take; a verified result becomes safely reusable through the cross-tenant cache; and the built thing can be published to the marketplace, where the participation economy pays the people who build.
Live and proven, versus being measured.
The product is honest about what is shipped and what is planned. The distinction between proven and being-measured is load-bearing across the entire investor case.
- The messenger-native intelligence that does real work: 10 paying teams using it daily
- Plan-act-verify execution with a visible verification step, demonstrable in-product
- The actions marketplace, where most of the visible product lives
- Provider-agnostic execution routing to the best model
- The exportable workspace repo, falsifiable in five minutes
- The cross-tenant cache and provenance ledger, shipped in PR #200
- Unprompted referral pull: the ten bring in people never marketed to
- The cross-tenant reuse curve: that reuse rises with scale and crosses between customers, the single number the business turns on
- The habit curve: that customers who arrive keep returning and running the same work weeks later
- On the roadmap: native Slack, Teams, and WhatsApp adapters
- On the roadmap: the seeder economy, turned on when reuse density warrants
- On the roadmap: the published open format and blessed third-party runtimes
Each layer answers a different competitor.
The product architecture is not incidental to the defensibility case; it is the defensibility case. Quinn's position is the seam between the static-workflow tools below it and the model vendors above it, and the seam is where value migrates as compute goes toward free.
| The layer | The competitor it answers | Why the competitor cannot easily follow |
|---|---|---|
| Does the work and checks it | Static-workflow automation | Trigger-and-action has no judgment layer; verification is a different architecture, not a feature toggle |
| The brain is yours to take | Model vendors' first-party assistants | A first-party assistant keeps memory inside the vendor; exit is against the vendor's interest |
| Cross-tenant cache | Any single model vendor | A vendor's cache cannot span work it does not host; Quinn's spans every customer on the shared surface |
| Participation economy | Any single vendor optimizing its own margin | A vendor cannot credibly pay an open builder base against itself |
| Open workspace format | Any proprietary platform | Vendors cannot refuse to interoperate with a standard the ecosystem runs on |
The static-workflow tools have the willingness-to-pay but not the judgment or the network. The model vendors have the intelligence but not the cross-tenant cache, the owned brain, or the open builder economy. The cache is the layer a vendor structurally cannot copy, and it is the one number the whole business turns on. You can watch it print on real traffic.