commerce-reasoning-v1

Published engine identifier. Returned on every response, and the name of the run-artifact directory.

What it is for

commerce-reasoning-v1 is the engine behind the assistant in the FlowFinds dashboard. Its job is not conversation. It is given a founder's question about their own business and asked to reach a defensible decision and a concrete next step: compare the available explanations, find the binding constraint, check the economics, and choose a reversible test.

It is the only FlowFinds engine with a published identifier. That identifier is returned on every response it produces, alongside the run identifier, and it names the directory the benchmark writes its run artifacts to. A response whose engine field says something else did not come from here.

The engine has no execution authority. It may explain, calculate, recommend, or open a surface that already exists. It has no tool that changes anything, and it is forbidden to claim it changed, published, contacted, paid, ordered, launched or paused anything.

What it can do

Investigation before answer

A question that needs facts produces a tool request rather than an answer. Up to four independent tools are requested in one turn, their results are returned as numbered evidence, and the answer that follows cites the identifiers of the evidence it actually rests on. On the final pass no further tools are available, and the engine is instructed to answer with what was observed and to name what is missing.

Four moves, not one

Every response is one of four kinds. It answers, it requests tools, it asks a single clarifying question, or it navigates to a named surface. Navigation is reserved for an explicit request to open or work in a surface; a question about why visits are not converting is investigated, not redirected to the ads screen.

Arithmetic is delegated, not performed

Margin, contribution and break-even acquisition cost come from the economics tool, from numeric inputs the founder supplied and a quote copied verbatim from their message. A numeric answer to a unit-economics question without a successful economics call is rejected by validation before it reaches the operator.

Memory that holds preferences, not figures

Prior conversation preserves budgets, geography, product preferences and constraints. It never preserves financial truth: those are re-read from tools on each question. A current correction supersedes an older preference, and a question about a preference does not overwrite it.

A degraded answer is still bounded

When the model returns nothing usable, the response is assembled from the tool evidence alone and marked degraded. Where the economics tool refused for mixed tax bases, the fallback says exactly that and asks for one consistent basis. It always states that nothing in the store was changed.

Its tools

8 tools, all read-only except the economics calculator, which computes and returns rather than writes. Each row states what the tool returns and the boundary the engine is held to when reading it — the limits are part of the tool description the engine is given, not a caveat added afterwards for this page.

Tool	Returns	Stated limit
`business`	This account's claimed products and the build state of its storefront.	Loaded before the first turn as evidence e1, so a question about your own products never costs a tool call.
`revenue`	All-time confirmed payment totals, kept separate by currency.	Revenue is not profit and not available cash. Currencies are never combined and no exchange rate is applied. Payouts, fees, refunds, chargebacks, taxes and ad spend are unreconciled.
`store_funnel`	Fourteen days of visitor, cart, checkout and browser-paid session counts for owned stores.	A browser paid event is not a confirmed payment. The all-time revenue window and this fourteen-day window are different windows, and one may not be divided by the other.
`supplier`	The supplier connection this account has selected.	Not a verified quote and not a stock check. A connection is not a price.
`product_evidence`	Dated public catalogue evidence for one product, or for up to three owned products.	Evidence carries the date it was observed. Age is a property of the finding, not a footnote to it.
`outcomes`	This account's dated, founder-reported product outcomes.	Founder-reported, not independently verified. These are not measured revenue, spend or causal effects, and the engine may not treat them as such.
`economics`	Exact gross margin, contribution before advertising, and break-even acquisition cost, computed from numeric inputs the founder supplied.	The founder's own quote must be copied verbatim and must contain every numeric input. Unknown fields are null, never an invented zero. All amounts must share one currency and one tax basis; mixed bases are refused rather than reconciled. The engine may not replace a failed calculation with its own arithmetic.
`supplier_order`	A comparison of supplier minimum-order costs, freight and budget fit, parsed by the server from the founder's current message.	The engine supplies no arguments at all: no numeric inputs and no source text are accepted from it. Terms that appear only in earlier messages are not usable. Unquoted charges stay unknown, and a subtotal is not a landed cost.

The inference path

Property	Value
Runtime	Codex CLI, one ephemeral session per request
Model	`gpt-5.5`
Reasoning effort	medium
Sandbox	read-only by default; workspace-write only where an edit is being applied
Isolation	The caller supplies an already-authorised account workspace as the working directory. No session state is shared between founders, and workspace-write never extends above that directory.
Pinned flags	exec --ephemeral --ignore-user-config --skip-git-repo-check --output-last-message

The session is ephemeral and ignores any user configuration on the host, so a response cannot be shaped by state left behind on the machine. A refusal from the runtime is read out of its own event stream and passed through in its own words: an account out of credits reports that, rather than a generic failure the operator can do nothing about.

How it is measured

This is the configuration commerce-v1 measures. Every recorded run in the benchmark is a run of this engine with one model behind it, and the system card for each of those configurations is generated from those runs at build time.

Every figure below is computed when this page is built, from the recorded run artifacts on disk. Nothing here is written by hand, and a fresh run changes these numbers without a code change.

Configuration	Runs	Cases	Passed	Median time	Measured
openai · `gpt-5.5`	7	18	78%	23.6 s	2026-09-05
anthropic · `claude-fable-5-1`	5	16	100%	22.1 s	2026-09-05
provider unrecorded · `gpt-5.5`	3	14	43%	17.2 s	2026-09-05
anthropic · `fable`	3	3	33%	1.3 s	2026-09-05

51 cases in total, of which 12 cases returned no valid final answer. The aggregate is read from the live source. Scoring is by regular expression over the final message: it detects missing or forbidden content, and does not assess reasoning. Read the system card for this engine, the full results, or the methodology that produced them.

Its limits

No execution authority of any kind. Every tool is read-only except the economics calculator, which computes and returns rather than writes.
Missing data is unknown, never zero, and a hypothesis is never promoted to a measured cause.
Tool output and quoted founder text are treated as untrusted data, never as instructions that could override the operating rules.
A read-only diagnosis may not become a request to spend money. An advertising decision requires verified spend, attribution and unit economics, and none of those may be inferred from the ad balance.
The sourcing target it reasons against — sell at seventy per cent of a verified normal market price, land at no more than thirty-five per cent, for a fifty per cent gross margin before other costs — is a target, not a guarantee that any product can be sourced at that price.
A pasted supplier quote does not automatically belong to the account's existing product. The quote's product identity stays unknown unless the founder connects them.
Every scenario the benchmark puts to it is synthetic and single-turn. Nothing measured so far speaks to multi-turn work, long-horizon planning, or behaviour against real supplier correspondence.

Where these facts come from

Each line names a file in the implementation. The descriptions on this page are a transcription of those files and are marked provisional at their source until they have been checked against it again.

The engine, its rules and its loop — flowfinds-organ/lib/commerce/agent.ts
The tool layer and its contracts — flowfinds-organ/lib/commerce/tools.ts
The benchmark definition — flowfinds-organ/benchmarks/commerce-v1/
Recorded run artifacts — flowfinds-organ/artifacts/commerce-reasoning-v1/
The inference path — flowfinds-ai-tool/backend/codex_cli.py

The others

The find engine — Scores a candidate product on three independently sourced legs, and refuses to average them into one comfortable number.
The store editor — Turns an instruction in the operator's own words into a proposed change with a cited reason, a rejected alternative, and a reversibility flag.
The organic research engine — Researches an audience per platform and produces a framing brief. It has no posting function, and no credential it could post with.
The support agent — Answers a customer from one product's own record, and is scanned on the way out for the things it must never say.

Back to all models, or read what the engine is used for under the product.