Done is a system decision.
WorkOS is the shared operational core beneath Creativ8, MOOSE and Kept. It models work as outcomes with owners, dependencies, proof and completion rules, so a person can finish their step while the system decides whether the work is actually done.
A checkbox is not a commitment.
Every team already has task tools, and none of them know when the work is finished. A task app tracks a title, an assignee, a due date and a status. That is enough to feel organised and not enough to run an operation. The moment work crosses two people, three systems and one shift change, the tool stops describing reality and the team starts running on memory, group chats and whoever cares most.
Four fields and a checkbox.
- task
- assignee
- due date
- status
Everything else is carried by the people involved, in their heads, until one of them is off shift.
Everything the checkbox hides.
- outcome
- owners, by step and by role
- definition of ready
- dependencies and external blockers
- handoffs between people and shifts
- approvals
- required proof
- definition of done
- exceptions and risk
- completion rules
Work is marked done when one person's portion is done. The visit is booked but the authorisation never came back. The table is seated but the allergy note never reached the kitchen. The feature is merged but nobody ran the review. Nothing was neglected and nothing is finished, because no system was holding the whole commitment.
One person can complete their step. Only the system can determine whether the full workflow is truly done.
Four of the eight things this outcome depends on are still open, and not one of them belongs to the person who just finished. A task tool would show this row as done and move on.
A medical assistant finishes vitals. The visit is not done. The order, the authorisation, the result and the follow-up are still open, and each of them belongs to someone else.
A host seats the table. The promise is not kept. Prep, stock, the room turnover and the partner confirmation all sit underneath a single sentence said to a guest.
An engineer merges the feature. The delivery is not done. Review, build, integration, sign-off and the wiki entry are the rest of the same commitment.
The core does not know what a patient is.
That is the whole discipline. WorkGraph models outcomes, steps, owners, dependencies, handoffs, proof and exceptions, and nothing else. It has never heard of a patient, a reservation, a room, a table, a build or a bug. Industry language arrives later, through configuration, and it is the reason one engine can run three businesses without forking into three engines.
Owners, dependencies, proof and handoffs are first-class objects, not fields on a task. That is what lets the completion rule at the bottom be a decision the system makes, rather than an opinion a person clicks.
The neutrality is enforced, not aspirational. A search of the three core packages, workgraph-core, workos-ui and workos-ai, returns zero occurrences of patient, reservation, guest, room, table, menu, clinic, hotel, feature or bug. Every vertical word in the system lives in a profile, an adapter or a surface slot.
Same engine. Four places to stand.
Progressive disclosure is the rule: the person doing the work sees one thing to do and why it matters; the manager sees risk, ownership and recovery; the administrator sees the process itself as an object they can edit. The diagrams below are drawings rather than screen captures. The foundation runs; its visual layer is still being built.
Because: the named owner is off-shift for 9h, the step is on the critical path, and the covering role has completed this step 14 times.
ApproveDismissBecause: two dependencies are unconfirmed and the remaining steps have never completed in under 6h.
The same engine, wearing three vocabularies.
This is the whole reason Auxerion can build deeply for three industries at once. Creativ8, MOOSE and Kept are not three codebases that resemble each other. They are three configurations of one engine, and the row that matters is the last one: underneath the language, it is the same object.
Every connection in this diagram runs one way. Products reach down through the seams; the core never reaches up. That single constraint is what keeps a fourth vertical a configuration exercise instead of a fourth codebase.
Seven ways in. None of them is a fork.
AppProfile
Name, brand, theme tokens, icon family, role labels, navigation, enabled modules, default views. One object defines what the product is called and how it looks.
DomainRegistry
Maps neutral concepts onto industry terms. This is where domainObjectType becomes a patient visit, a guest service or a feature delivery.
TemplatePacks
Industry and team process libraries layered on top of the generic base, so a new customer starts from real workflows rather than an empty builder.
ProofTypeRegistry
What counts as evidence here. A screenshot and a build artifact in one product; a signature and a room check in another. The completion rule is shared; the proof is not.
Adapters
Ingest domain records into neutral work objects and map context back out. Three exist today: Creativ8, MedTech and FoodTech, each with contract tests proving it never contaminates the core.
CapabilityFlags
Runtime toggles for Process Designer, AI recommendations, handoff board, audit timeline, schedule and training. A product ships the surfaces it has earned.
SurfaceSlots
Safe extension points inside the shared detail shell, where a product adds its own context panels without touching shared layout or engine logic.
Reuse through extension, not forks. A product may add a profile, an adapter, a template pack, a proof type or a slot. It may not edit the shared engine to make its own case work. The day one product patches the core for itself is the day Auxerion has three codebases again.
Each vertical costs less than the last.
A shared core is only worth its overhead if the fourth product is cheaper than the third. That is the test WorkOS is built to pass, and it is the test we expect to be held to.
The vertical pays for the core.
The engine, the surfaces, the proof model and the audit trail are all built once, inside the first product that needs them. Expensive, and correctly so.
The vertical pays for its own language.
A profile, a registry, an adapter, a template pack, a set of proof types and a handful of context panels. The workflow engine, the manager surface and the audit trail arrive already built and already tested.
The vertical is a configuration exercise.
Facilities, staffing, education, professional services. Each one is a domain vocabulary and a set of templates on a core that three real businesses have already hardened.
This is a design target, not a measured result. Creativ8, MOOSE and Kept are each at a different stage, and none has yet been migrated onto the foundation end to end. The claim on this page is that the architecture is built to make that migration additive, and the adapters, contract tests and neutrality checks exist so the claim can be checked rather than believed.
Running, tested, honest about the rest.
Auxerion labels every product by what it actually is. WorkOS is a working foundation with a mock-first data layer: the architecture, the engine and the extension model are real and under test; the production backend, the integrations and the visual polish are the next phase.
Eight shared packages and one runnable Next.js reference app, wired with pnpm and Turborepo.
RunningCompletion logic, dependency resolution, blocker evaluation, proof requirements, handoff state and health scoring, as pure TypeScript with no UI and no industry.
Running · testedNinety-four tests across thirty-one files, covering the engine, profile validation, adapter contracts, mock services, the AI contract layer and every product surface.
94 passingCreativ8, MedTech and FoodTech adapters, each proven by contract test to map domain records into neutral objects without leaking terms into the core.
3 of 3My Day, Mission Control, Workflows, workflow detail, Process Designer and WorkPilot, running against seeded scenarios for blocked steps, missing proof, failed handoffs and critical-path risk.
First passTyped mock services behind the same contracts a real backend will implement, with a provider-backed session seam and a session audit trail already in place.
Mock-firstDatabase, identity, permissions and external connectors fit behind the contracts the foundation already defines. Not started.
Next phaseWorkOS is internal infrastructure. It is what makes Creativ8, MOOSE and Kept possible; it is not a fourth thing to buy.
NoThe architecture is
the argument.
For investors asking how one company builds credibly for three industries, and for technical partners who want to see the core rather than the pitch, we will walk you through it directly.
troy@auxerion.com