The Gateway runs named mathematical methods and returns their raw results. The Harness composes them into continuing workflows. The Product Compiler is being built to turn a customer deep dive, connected facts, and a goal into a saved composition, working preview, cassette, or full application. Each new outcome will rerun the same composition and publish the latest supported answer.
Precise can keep a small product team because the reusable parts are already distinct: 24 math methods, continuing workflows, source and goal records, decision learning, grounded chat, product projections, and Boombox operating rails. The Product Compiler will assemble those parts into bespoke customer products at repeatable speed. It is in development.
app_rev_4ac0c1d7 · older builddescribe + estate coverage + estate driftSelect a shape to see what runs, what persists, who owns the result, and how the same capability expands from one calculation to a customer product.
A caller sends JSON to one named method and gets the literal retained result. This is the smallest public surface for a workflow author, researcher, or advanced customer.
gateway.run/v1 record with output, diagnostics, versions, and digests.math run
{
"request_id": "book-2026-09-02",
"method": "contribution/pairwise-interaction",
"input": { "mode": "sampled", "players": ["…"] },
"seed": 17,
"resources": { "samples": 4000, "time_ms": 30000 }
}
The boundary is practical: typed requests, results, and references move between layers. Product meaning, raw tenant data, credentials, and customer ownership do not transfer with hosting.
| Layer | Owns | Receives | Returns | Does not decide |
|---|---|---|---|---|
| Customer or source system | Facts, permissions, business goal, operational authority | Product result or authorized action | Source records, outcome events, action status | Which estimator Precise should run |
| Precise Product | Customer relationship, source map, goal, recommendation, action, history, learned state | Connected facts and raw method or workflow results | A Board, recommendation, report, grounded answer, or action request | How Boombox operates the host |
| Company Harness | Workflow definitions, input transforms, comparisons, artifact interpretation | Product facts and goals | Versioned workflow cycles plus Product-ready evidence | External write authority |
| Precise Gateway | Method catalog, implementation binding, execution controls, raw result records | Named method plus JSON input | Literal output, diagnostics, version, and digest | Whether the result is commercially wise or causal |
| Boombox | Identity, tenant binding, deployment, stores, secrets, schedules, events, operational receipts, capability distribution | Opaque Product artifacts and typed operating requests | Runtime, custody, delivery, operation facts, lifecycle receipts | Precise math, workflow meaning, Product judgment, or the customer relationship |
Precise owns the Product and differentiated math. Another company can own its own Harness, artifacts, actions, and customer surface while consuming the same Gateway methods.
A method call is useful on its own. Most Products will call workflows and keep method names under “How calculated” or “What changed.”
Modeled example data · seed 17
math commandsmethodsList mounted versions, schemas, and scaling modes.runRun one named method and retain its terminal result.resultRead a retained result by run_id.statusRead active process state or retained terminal state.cancelRequest cancellation; separate from not_computable.nEach method declares how its work grows with input size.exactShapley is exact through 20 players. Pair interaction and Owen are exact through 16.sampledContribution methods support seeded estimators at larger sizes. Pair requests can stay sparse.HTTPPublic Gateway body: 1 MiB. Remote worker body: 16 MiB.resultsmath run waits for a terminal result and retains it by run ID.| Method | Family | Returns |
|---|
Contribution
Source
Use one method for one calculation. Use a workflow when dependencies, comparisons, and new outcomes belong to the same continuing analysis.
Modeled example data · seed 17
workflow commandsworkflowsList named definitions and resolved method versions.startRun or reattach the first immutable cycle.focusRun a caller-selected method set for one cycle.outcomeVerify exact bytes and append a duplicate-safe cycle.resultRead the current workflow record.definitionWorkflow version and implementation-bound method versions.cyclesComplete step inputs, outputs, diagnostics, and raw run references.comparisonsSame-method variants and changes from the prior cycle.outcomesAccepted event IDs, exact bytes, parsed values, and patches.pendingCompleted steps are reused after restart; unfinished work reruns.| Workflow | Steps | Use |
|---|
A focused workflow runs any selected mounted method set for one cycle. The four named workflows keep receiving outcomes.
Source
Twenty-one explorable families cover the 46 generated estate descriptors plus the useful Svelte, Next.js, research, transport, and optional surfaces around the default tree. Open any family for its exact interface, current operating state, example, and source.
| Capability family | Kind | State |
|---|
·
Source
Generated estate snapshot
The family view explains how the parts compose. This table carries all 46 generated records with their lifecycle, Harness connection, telemetry level, repository path, and inspection command.
| Descriptor | Kind | Lifecycle | Harness |
|---|
·
Sourceharness/src/precise-estate-catalog.ts
In development
The Product Compiler will listen to the customer problem, bind it to connected facts and a measured goal, find the controls, compose the useful Precise capabilities, show a working product, and save it for the next customer and the next outcome.
Stage 1 of 9
{
"schema": "precise.product-composition/v1",
"name": "weekly-cpa-move",
"version": "1.0.0",
"compiled_from": {
"discovery_ref": "precise:product-discovery/sha256:example"
},
"source_requirements": [
{
"source_role": "media-delivery",
"required_fields": ["spend", "conversions", "creative", "placement", "supply_path"],
"required_grain": ["creative", "placement", "supply_path"],
"time_requirement": "daily",
"maturity_requirement": "conversion window closed"
}
],
"goal_requirement": {
"measure": "cost_per_acquisition",
"direction": "decrease",
"window": "weekly"
},
"primitive_contract": {
"dimensions": ["creative", "placement", "supply_path"],
"controls": [{ "field": "budget", "mode": "manual_action" }],
"measures": ["current_size", "measured_contribution", "uncertainty", "interactions", "marginal_value"]
},
"workflow_program": [
{ "purpose": "understand", "workflow": "understand-the-book", "trigger": "first-run" },
{ "purpose": "move", "workflow": "find-the-next-move", "trigger": "source-change" },
{ "purpose": "test", "workflow": "design-the-test", "trigger": "first-run" },
{ "purpose": "learn", "workflow": "measure-and-learn", "trigger": "outcome" }
],
"surface": "current-answer-with-history-and-chat",
"package_shape": "application"
}
Precise owns the Compiler, product meaning, workflow choice, and customer result. Boombox supplies the reusable cassette, application, identity, event, schedule, deployment, and receipt rails underneath it.
The separation is useful because each record answers a different everyday question: what did the math return, what did the customer do, and did the software run.
Question: What did pairwise interaction return for this exact input?
Question: How did the full answer change after this week's outcome?
Question: What did we recommend, what actually moved, and was it useful?
Question: Did the scheduled run execute and where is its result?
Modeled example data · seed 17
| What happened | Workflow record | Product record | Host record |
|---|---|---|---|
| A $10k video to search move prices at +150 outcomes | Method input, +150 result, [135, 165] sensitivity band, exact version | Recommendation with its source and evidence meaning | Gateway invocation completed |
| The customer moves $8k instead | The earlier $10k calculation stays unchanged | Actual exposure records $8k, time, unit, and override | Action adapter receipt records the downstream call |
| Mature conversions arrive | New outcome patch produces the next complete cycle | Outcome and score compare the frozen recommendation with actual $8k exposure | Event delivery and workflow run complete |
| The next recommendation changes | Prior cycles stay readable beside the new math | The lesson and current answer explain the change | The next scheduled or event-driven run gets a new operation ID |
The last complete Product answer stays visible during recomputation. A later cycle is rebuilt from original inputs plus explicit outcome patches, so a changed answer can always be traced to changed facts or code.
In development
Connect the DSPs, warehouse, object store, APIs, or files once. The compiled product will follow changes, resolve advertisers and campaigns inside the source, and keep each current answer at the finest supported controllable grain.
understand-the-book supplies contribution and pair interactions. find-the-next-move supplies marginal value, saturation, scenarios, and portfolio structure. design-the-test sizes the next useful test. measure-and-learn recalculates as outcomes mature. The Product Compiler will bind those results to one source release and goal, then turn them into the decision, history, and explanation the customer sees.
| Customer job | Compiled product behavior | Precise parts underneath | Visible result |
|---|---|---|---|
| Connect data | Resolve source changes through polling or events and produce a synchronized release. | Source ports, workspaces, tolerant readers, mappings, custody | Advertiser and campaign views that stay current |
| Set the goal | Bind the measured objective and window to every calculation and answer. | Media Goal, Product instance, source release | Current result against the actual goal |
| See what can change | Project creative × channel × audience × placement or the finest grain the source supports. | Contribution, Owen groups, pair interactions, gradient, source map | Dense controllable rows with size, value, uncertainty, and pair effects |
| Choose the next move | Combine marginal value, response, portfolio overlap, uncertainty, and the goal into one recommendation and range. | Next-dollar, saturation, portfolio, calibration, Product Compiler | One move or coordinated set of moves with supported bounds |
| Apply it | Use the connected DSP or operations adapter when automation is available; otherwise hand off the exact action. | Action adapter, Product authority, Boombox invocation | Actual exposure, time, amount, and downstream receipt |
| Learn continuously | Join mature outcomes, score the earlier answer, rerun the workflows, and publish the next answer. | Decision Learning, workflow outcome, Product current | A simple progression toward the goal |
| Drill down or ask | Open the raw method, workflow cycle, source, and evidence behind any number, or ask in plain language. | Gateway results, Harness history, grounded chat | A direct explanation pinned to the same answer |
The same existing core can serve one API call, a scheduled cassette, an agent, or a full customer application. The implementation stays in place while the operating surface grows around it.
Wrap the real library, CLI, service, or Harness command. Give it a typed input and output and keep the existing tests as its behavioral authority.
core → method or capabilityName the steps, dependencies, inputs, retained outputs, and continuation event. The company owns this workflow and the artifact it produces. It can consume Precise math alongside its own domain method.
methods → workflow → artifactChoose manual, event, or schedule input. A cassette can run the workflow, retain its typed result, publish it, or use a connected action capability.
trigger → run → receiptPackage UI, Product API, Harness, source adapters, action adapters, and Product state as one release that can run in a Precise or customer target.
release + target → deploymentnpm install --save-dev --save-exact --ignore-scripts \ @konstantdotcloud/boombox@0.14.10 node ./node_modules/@konstantdotcloud/boombox/dist/boombox.js \ project init . --client codex --client claude --json
npm run precise:app:new -- --slug my-first-app node scripts/precise-install.mjs my-first-app npm --prefix packages/my-first-app run gateway # The blank app starts with one tenant-bound Gateway, # empty handles and jobs, and no invented Product core.
precise-weekly-budget-shift.cassette.tsimport {
approvals, defineCassette, defineHostService,
input, manual, outputs, ref, schedule, stage
} from "@konstantdotcloud/boombox";
const precise = defineHostService({
server: "precise-campaign-improvement",
source: "tenant_registry",
tools: { modelShift: "precise_campaign_budget_shift_model" }
});
export default defineCassette({
id: "precise_weekly_budget_shift",
version: 2,
identity: {
name: "Weekly budget-shift model",
description: "Run the existing Precise model and retain its typed result.",
tags: ["precise", "campaign"]
},
inputs: {
request_id: input.string({
description: "One stable ID for the current source release; a later release gets a new ID."
})
},
triggers: [
manual(),
schedule({ cron: "0 9 * * 1", timezone: "America/New_York" })
],
governance: { approvals: approvals.none() },
flow: [
stage.agent({
id: "model_shift",
task: "Call precise_campaign_budget_shift_model once. Return its result unchanged.",
input: {
campaign_id: "campaign-42",
request_id: ref.input("request_id"),
move: {
from_label: "Open Exchange",
to_label: "Private Marketplace (PMP)",
dollars: 50000
}
},
output: {
as: "result",
schema_ref: "CampaignBudgetShiftEnvelope@v1",
require_valid_json: true,
on_validation_error: "fail"
},
tools: {
allow: [precise.modelShift.ref],
required_calls: [precise.modelShift.ref]
}
})
],
outputs: { primary: outputs.primary({ from: ref.stage("model_shift") }) }
});
./node_modules/.bin/boombox cassettes build \ ./precise-weekly-budget-shift.cassette.ts ./node_modules/.bin/boombox cassettes dry-run <draft_id> --draft ./node_modules/.bin/boombox cassettes publish <draft_id> \ --name precise_weekly_budget_shift --version 2 ./node_modules/.bin/boombox run precise_weekly_budget_shift \ --input request_id=campaign-42:<source-release-digest> ./node_modules/.bin/boombox runs list \ --cassette precise_weekly_budget_shift --since 24h ./node_modules/.bin/boombox runs show <run_id> --logs ./node_modules/.bin/boombox schedules list
return defineApplication({
schema: "boombox.application-descriptor.v1",
application_id: "precise_campaign_improvement",
product_version: input.product_version,
artifact: {
artifact_ref: input.artifact_ref,
artifact_digest: input.artifact_digest,
manifest_ref: input.manifest_ref,
manifest_digest: input.manifest_digest,
attestation_ref: input.attestation_ref,
attestation_digest: input.attestation_digest,
residency_class: input.residency_class,
region: input.region,
frontend: { kind: "bundled", path: "/", digest: input.frontend_digest },
harness: {
contract_ref: "precise://product/campaign-improvement/v1",
command: ["node", "packages/campaign-improvement/build/index.js"],
port: 3000,
health_path: "/healthz",
api_path: "/api",
mcp_path: "/mcp"
}
},
commands: [
"decision.view", "workspace.synchronize", "workspace.analyze",
"analyst.answer", "report.export", "trust.evaluate"
],
declared_intents: [],
surface: { kind: "bundled_frontend" },
data_handles: [],
secret_refs: input.secret_refs,
connector_grants: input.connector_grants
});
npm run campaign-improvement:preview:plan --silent ./node_modules/.bin/boombox app targets --json > /tmp/app-targets.json node ./plan-app.mjs ./descriptor.json /tmp/app-targets.json preview 0 \ > /tmp/app-bundle.json ./node_modules/.bin/boombox app apply /tmp/app-bundle.json ./node_modules/.bin/boombox app inspect <deployment_id>
The cassette adds a trigger, typed result, run history, and schedule to one useful operation. The application adds the customer surface, Product state, API, adapters, and Harness without changing the underlying math or workflow contract.
These examples match the repository-pinned @konstantdotcloud/boombox@0.14.10. The package export and connected target catalog are the executable contracts.
Each provider keeps its operation, IP, version, evidence, economics, and support. Each customer keeps its data, mandate, Product surface, and downstream relationship. Boombox makes the expensive horizontal connection reusable across separately admitted estates.
Protection from disintermediation: the customer builds its differentiated Product on stable capability seams while keeping its data, expertise, and customer relationship. Precise stays in the value path as the contribution-math provider. The data science lab can add methods and workflows once, and every saved composition can pick them up deliberately.
It can host a bounded cassette, an application, a durable workload, a scheduled subject job, or an admitted capability connection. The Product contract stays the same across those shapes.
| Operating shape | Use | Boombox supplies | Product keeps |
|---|---|---|---|
| Cassette | Repeatable bounded calculation, judgment, or action. | Admission, invocation, receipt, optional publication. | Command meaning, evidence, result, and outcome. |
| Portable application | Frontend plus Product API and Harness. | Deployment, identity, secrets, events, lifecycle. | UI, workflows, customer result, customer relationship. |
| Durable workload | Backfill, model grid, large or restartable work. | Logical run, retries, fencing, recovery, terminal receipt. | Worker logic, scientific meaning, result artifact. |
| Scheduled subject job | Per-campaign or per-entity refresh. | Subject identity, heads, custody, schedule. | Snapshot meaning and reduction behavior. |
| Capability connection | Use a provider or customer-owned tool from an existing codebase. | Discovery, tenant-bound invocation, operation receipt. | Tool schema, expertise, release, and customer authorization. |
That makes the page useful to an engineer deciding what they can call now and what they can build into next.
24 methods, four continuing workflows, focused execution, local-file and GCS run, workflow, and outcome stores, deterministic Gateway bundle, Campaign Improvement calculations, and Decision Learning records.
The last recorded staging observation is app_rev_4ac0c1d7 on 2026-09-02. It serves the earlier Campaign Improvement Gateway. The current math and continuing-workflow build is newer repository code.
Product compilation, source and goal to method-input mapping, current-answer projection, outcome joins, math and workflow operation reporting, cassette and application emitters, the current staging revision, and connected downstream action adapters.
This page explains the system. The running commands and source below decide what is available in the checkout you are holding.
cd harness npm run precise -- describe npm run precise -- math methods npm run precise -- workflow workflows npm run precise -- estate coverage npm run precise -- estate drift
Source document