ExpertiseOS

Budget and permissions are authorized separately. Reviewing reserves nothing, and security or leakage failures can't be overridden.
A two-sided, verified marketplace — buyers search by outcome; trust and price bind to the exact Service Version.
Work runs against the exact version you authorized inside a locked-egress Codex runner — credits reserved, never charged until you accept.
Charged only when the checks pass: if protection blocks delivery you pay nothing; on acceptance credits settle 80/15/5.
ExpertiseOs hires verified expertise for a bounded capability gap — strictly inside your budget, trust, and approval limits.
One workspace for people and AI agents — describe an outcome, get a planned, protected, receipt-backed result.
You describe the outcome; the planner returns an immutable plan — owning services, budget, and human-decision gates, before any spend
Providers publish by conversation: an AI guide interviews them one question at a time while the source package stays private.

Inspiration

Two observations collided.

First: every coding agent eventually hits a wall — a domain decision it can't make, a regulation it doesn't know, a judgment call that needs ten years of scar tissue. Today the agent either guesses (and fails silently) or stops and waits for a human. Neither scales.

Second: the people who have that scar tissue — senior engineers, compliance experts, domain specialists — can only sell their expertise one meeting at a time. Their knowledge is valuable 24/7, but they can only be awake 16 hours a day.

And between those two observations sits the reason this market doesn't exist yet: experts are terrified of being copied. The first time you hand your playbook to an AI system, you assume you've sold it forever. So the knowledge stays locked in heads, and agents keep guessing.

ExpertiseOS is our answer to all three: package your expertise once — sealed, verified, never exposed — and let both humans and AI agents hire it on demand, even while you sleep.

What it does

ExpertiseOS is a two-sided expertise network with exactly two entry points.

I have expertise — A conversational interview turns what you know into a structured, evidence-backed Expertise Asset. From that moment, the system is built around one promise: your expertise works for buyers, but it never leaves the vault.

The asset is sealed by design. Playbooks, decision rules, worked cases, failure cases — none of it is ever downloadable or visible to buyers. What's public is only the Expertise Passport: verified metrics, boundaries, and proof that it works — the résumé, never the brain.
Provenance before publication. Every extracted claim carries item-level source anchors and must be explicitly confirmed by you. An AI hypothesis without your confirmation can never be published under your name.
Verification without exposure. Your expertise is benchmarked against a challenge set where a meaningful share of cases are hidden and system-generated — so results are trustworthy, yet no one (including you) can overfit or reverse-engineer the evaluation.
Protected execution. When a buyer's agent hires your expertise, the expertise runs inside the platform's protected boundary. The buyer receives decisions, corrections, and outcomes — with audit evidence — but never the reasoning asset that produced them.
You earn while you sleep. Every run draws from your sealed asset and pays into a transparent usage pool. Your knowledge takes the night shift; you don't.

I need expertise — Describe work conversationally. The system drafts a work plan; you explicitly authorize budget (in credits), scope, and human-approval boundaries before anything runs. When the executing agent detects a capability gap mid-run, it autonomously matches and hires verified expertise, applies expert-guided corrections, and runs acceptance checks. Credits settle only after those checks pass — and you receive concrete deliveries, like an open pull request, not a chat transcript.

How we built it

We built ExpertiseOS during OpenAI Build Week as one executable workflow spanning Provider authoring, buyer planning, agent execution, verification, and settlement.

How GPT-5.6 was applied

GPT-5.6 played two concrete roles in the project:

Building the product through Codex. We used GPT-5.6 through Codex for cross-spec reasoning, architecture planning, edge-case discovery, implementation review, debugging, UX critique, and test design. It helped trace changes across the Next.js web app, NestJS control API, execution worker, PostgreSQL policies, shared contracts, and MCP integration.
Running the buyer planning workflow. The demonstrated planner uses a pinned local Codex CLI with GPT-5.6 Sol. It receives a bounded buyer brief and returns a strict, schema-validated project plan. In the recorded run, GPT-5.6 generated a six-service plan with one human-owned blocking decision in 17.8 seconds.

GPT-5.6 proposes the plan, but it does not control matching, pricing, authorization, or settlement. Those decisions remain deterministic and policy-enforced.

What we implemented

AI-guided Provider Studio: document-first or chat-first intake, one-question-at-a-time interviews, resumable sessions, provenance- linked proposals, and explicit Provider confirmation.
Private expertise contracts: protected source material is separated from the public Expertise Passport containing boundaries, price, version, and verified performance.
Versioned marketplace: buyers and agents select an immutable Service Version rather than an editable provider profile.
GPT-5.6 project planning: a buyer brief becomes a schema-validated service graph with deliverables, ownership, budget, and required human decisions.
Agent capability-gap detection: a connected agent can stop when it reaches a high-risk knowledge boundary instead of silently guessing.
Policy-governed hiring: deterministic rules select an eligible exact Service Version and enforce budget, trust, and permission limits.
Protected execution: the worker receives only minimum-necessary buyer context and capability-scoped provider knowledge.
Human authority: business, legal, budget, publication, and production decisions remain explicitly human-owned.
Outcome-based settlement: credits settle only after acceptance checks pass; failed or protection-blocked work is not charged.
Audit and evidence: state-changing operations use idempotency, append-only audit metadata, immutable receipts, and version-pinned evidence.

How Codex accelerated the work

Codex operated as a repository-aware engineering collaborator rather than a one-shot code generator. It helped us:

translate product requirements into specifications, implementation plans, and acceptance criteria;
propagate contracts across the web app, API, worker, database, and MCP boundary;
implement and review authorization, PostgreSQL RLS, idempotency, audit, and protected-data controls;
investigate failures across multiple packages and propose the smallest compatible fixes;
run Consumer and Provider UX walkthroughs and convert findings into functional and accessibility improvements;
create regression, contract, integration, security, and browser-level evidence;
preserve compatibility with earlier project and finance contracts while adding the new agent workflow.

What remained human-owned

We retained ownership of the product and risk decisions, including:

positioning ExpertiseOS as a protected expertise network instead of a generic document marketplace;
deciding which actions require human approval;
keeping prompts, model traces, retrieval internals, and private source fragments out of the buyer experience;
defining immutable Service Versions and outcome-based economics;
deciding where generative reasoning must stop and deterministic enforcement must begin;
reviewing every proposed change and deciding whether it was safe to implement.

What is real and what is test-mode

The recorded video includes a real Codex CLI invocation using GPT-5.6 Sol, persisted planning output, Provider authoring, exact-version selection, human decision handling, acceptance checks, and receipt generation.
Credits and some protected-execution evidence are explicitly labeled as Test-mode or deterministic evidence. Production payment rails, legal-grade identity, and stronger hosted execution guarantees remain future release gates and are not claimed as production-complete.

The build started with a question we couldn't shake: what does it actually mean to "hire" someone's judgment — without meeting them, without reading their playbook, possibly without even being human?

We tried answering it the obvious way first: expertise as documents, retrieval on top. It failed immediately, and the failure was instructive. A playbook you can retrieve is a playbook you've already given away — and raw documents don't carry the thing buyers actually pay for, which is judgment: knowing which rule applies, when to break it, and what failure smells like.

So we inverted the architecture. Instead of moving knowledge to where the work is, we move the work to where the knowledge is sealed. That single inversion became the spine of everything we built:

Expertise became a contract, not a corpus. We designed a representation that separates what an expertise is (private: sources, decision rules, worked and failed cases) from what it promises (public: the job it completes, its boundaries, its verified performance). Agents negotiate with the promise; only the protected runtime ever touches the asset.

Extraction became a conversation, not an upload. Getting judgment out of a person's head is an interviewing problem. We built an AI interviewer that probes for the questions people repeatedly bring to the expert, the situations that demand judgment, and what good and bad outcomes look like — then binds every extracted claim to its exact source, so the expert stays in control of every sentence published under their name.

Trust became measurable without disclosure. The hardest design problem of the week: how does a buyer — or a buyer's agent — trust expertise it's not allowed to see? Our answer combines pinned-baseline benchmarking (every lift metric locks the model, configuration, and evaluation version it was measured against) with hidden challenge cases the provider never sees. Provable performance, zero exposure.

And the agent became a customer. The final piece was teaching an agent run to recognize the boundary of its own competence — to stop mid-execution, articulate the gap, hire matched expertise, and continue with expert-guided corrections. Watching a run pause itself and say, in effect, "I need help, and I know exactly whose," was the moment the idea stopped being a pitch and started being a product.

One week wasn't enough to productionize every rail — payments, legal-grade identity, host certifications. We made a deliberate call: mock honestly. Every capability ships as a complete, deterministic journey, clearly labeled, with its production replacement documented — so the demo shows the real system's shape, not a highlight reel.

Challenges we ran into

The confidentiality paradox. The entire product depends on convincing experts to encode their most valuable asset into a system explicitly designed so no one can read it back — including proving to them that we can't leak it either. Sealed assets, passport-only publicity, and protected execution weren't features; they were the price of the market existing at all.
Trust without transparency. Buyers demand proof; providers demand secrecy. Threading that needle with hidden evaluation cases and pinned baselines took more iterations than anything else we built.
Teaching an agent to know what it doesn't know. Gap detection that fires too eagerly turns every run into a shopping spree; too conservatively, and the agent ships confident garbage. Calibrating that boundary was the week's most interesting technical fight.
Two species of users, one product. Humans need conversation and clear authority over budget and boundaries; agents need machine-readable contracts and deterministic settlement. Designing one model both could act on — without forking the system — forced several full redesigns.

What we learned

Security is the business model, not a feature. The expertise economy doesn't exist because protection doesn't exist. Solve the vault, and the marketplace follows.
Provenance is the product. The moment every claim links to an exact source, trust stops being a marketing word and becomes something an expert can point to.
Settlement design is incentive design. "Credits settle only after acceptance checks pass" reshaped everything upstream — verification, pricing, refund logic all fell out of that one rule.

What's next for ExpertiseOS - The expertise network for humans and agents

A production MCP connector so any agent host can hire sealed expertise natively
Hardened protected-execution guarantees and real settlement rails
Onboard the first cohort of providers — and send them their first "you earned credits while you slept" notification