foxo

Thepre-sales plane.

Every company that sells software runs the same motion by hand: find them, research them, show them, qualify them. foxo is the layer that runs it — governed, auditable, and yours to declare.

Governed agent fleets execute it end to end, and every judgement they make is a typed, versioned, auditable object. Not a prompt.

Enter the console → Read the thesis
console liveapp.foxo.pro two tenantsin production zero shared vocabularyby design
icp / registry.yamlv7 · declared
# who is worth selling to — typed, not described attribute: has_live_product_surface type: boolean source: crawler.product_surface gate: hard attribute: demoability type: score(0..100) source: tool:demoability@v3 gate: soft weight: 0.34 attribute: procurement_cycle_days type: int source: — // none declared gate: soft # evaluation does not guess: result: not_evaluable ← 1 attribute unsourced
foxet · demo_surface agrizy · commodity_class foxet · trial_depth agrizy · grade_spec foxet · onboarding_friction agrizy · licence_on_record foxet · demoability@v3 agrizy · lot_tonnage foxet · buyer_role agrizy · processing_tier foxet · product_surface agrizy · nutraceutical_extract foxet · replayable_demo agrizy · arrival_window
§01the break

Pre-sales broke because nobody wrote down the judgement.

Every pre-sales system in the market is a faster way to act. None of them is a way to state what you believe — about who is worth the quarter, about what makes a prospect ready, about what should never go out of the door. So the belief lives in a sales leader's head, a spreadsheet nobody owns, and a prompt someone edited on a Thursday.

01

The list is bought.

You inherit a vendor's definition of a good customer, pay for it by the row, and spend the next two quarters discovering it was wrong. The definition itself was never yours to inspect, correct, or version.

02

The research is a prompt.

Run it today and the account looks promising. Run it tomorrow and it does not. There is nothing to diff, nothing to attribute, and no way to tell a model's bad day from a market's real change.

03

The score is a number.

An account is a 74. Nobody can say which inputs moved it, which formula produced it, or whether the 74 and last quarter's 74 were computed by the same thing. Numbers from different eras sit in one column and are averaged together.

04

The send is a button.

Every rule about who must never be contacted lives in someone's memory, and the only record of what went out is the outbox. When it goes wrong, the investigation is archaeology.

Each of those is a missing declaration. The category has spent a decade building faster ways to act on judgement nobody ever wrote down.

§02the plane

A plane, not a tool.

A plane is the layer the rest runs on. Models get swapped, channels get added, agents are spawned and retired, vendors come and go — the plane is where the judgement lives, typed and versioned and legible to the person who has to defend it in a board meeting. Six primitives carry the whole thing.

PRIMITIVE 01

A declarable ICP.

Who is worth selling to is a typed registry — attributes with hard gates, soft gates and weights. Each attribute declares the data source that answers it. An ICP that cannot be evaluated returns not_evaluable; it does not quietly return "matched".

icp.evaluate()registry v7
hard has_live_product_surface pass hard region in {IN, SG, AE} pass soft demoability = 71 × 0.34 soft procurement_cycle_days → unsourced verdict = not_evaluable # the honest answer is an answer
PRIMITIVE 02

The schema is the tenant's, not the vendor's.

Every business object has a frozen base schema. Everything past it is declared per tenant — typed, with closed vocabularies. An undeclared field is a rejected write, not a stored one. Your vocabulary is not a custom-field text box; it is part of the contract.

schema / company.customtenant-scoped
base (frozen) name domain region declare demo_surface enum [web_app, api, mobile] declare trial_depth int write { vibe_score: 88 } → rejected · undeclared field
PRIMITIVE 03

Scores are tools, not numbers.

A metric like demoability is a named, versioned function with declared inputs. Change the formula and you bump the version — every value computed by the old one is visibly stale rather than silently mixed in. Only the tool that owns a field may write it.

tool / demoabilityv2 → v3
inputs demo_surface, trial_depth, onboarding_friction owns company.demoability (sole writer) stored acme 71 @v2 stale stored northwind 64 @v2 stale stored hyperloop 82 @v3 current # nothing averages across versions
PRIMITIVE 04

Provenance on every value.

Each fact carries where it came from, how confident it is, which tool wrote it and at which version. When two sources disagree, the winner is chosen by a stated rule — and the loser is kept, so the disagreement itself is evidence rather than a thing that vanished.

value / acme.employee_count2 claims
claim 240 src filing.registry conf 0.93 tool co_ingest@v4 winner claim 310 src careers_page conf 0.58 tool crawler@v9 retained rule prefer(filing) > prefer(crawl) # the loser is never deleted
PRIMITIVE 05

A send gate, not a send button.

Every outbound action passes a synchronous governor with explicit rules before it exists in the world, and every decision — release, hold, block — is written to the record. Suppression is append-only. If a list can be lifted from a UI, it was never suppression.

gate / outboundsynchronous
action email → acme / head of product rule suppression clear append-only rule consent clear rule score_freshness @v2 stale decision HELD · recorded · replayable
PRIMITIVE 06

Isolation is structural.

Row-level security is forced at the database and keyed to the tenant, and the application role cannot bypass it. Isolation stops being a convention a query might forget and becomes a property of the system — the kind you can hand to a security reviewer instead of describing.

db / policyforced
ALTER TABLE company FORCE ROW LEVEL SECURITY; POLICY tenant_scope USING ( tenant_id = current_tenant() ); app_role NOBYPASSRLS enforced # a forgotten WHERE clause returns nothing
§03worked example

Nothing leaves without a decision on the record.

Turn the rules off and on. The governor re-decides synchronously, names the rule that decided it, and appends to the ledger below. The ledger is append-only — exactly like the real one, there is no button here that makes a decision disappear.

gate rules · outbound 6 / 6 satisfied
decision RELEASED

All hard rules clear and all soft rules clear. The action is released, and the decision is written before the send, not after it.

decision ledger · append-only · no delete path

About this panel: it is a diagram you can operate — the logic runs in your browser on an illustrative action. It is not live tenant data, and no figure on this page is a measured result.

§04in production

Same plane. No shared vocabulary.

The test of a plane is whether two businesses that share nothing can run on it without either of them bending to the other's words. Two tenants run on foxo today. One sells autonomous product demos to B2B software companies. The other trades agricultural commodities and nutraceutical ingredients. They have no product vocabulary in common at all — and neither one's schema is a compromise.

Foxet

Autonomous AI product demos for B2B software. A good prospect is one whose product can be demonstrated by a machine.

declared vocabularytenant: foxet
demo_surface enum [web_app, api, mobile] trial_depth int onboarding_friction score(0..5) demoability tool@v3 buyer_role enum [product, growth, rev_ops] hard gate has_live_product_surface
Agrizy

Agri-commodity and nutraceutical trade. A good counterparty is one whose grade, licence and lot economics actually clear.

declared vocabularytenant: agrizy
commodity_class enum [grain, spice, nutra] grade_spec enum [food, feed, pharma] licence_on_record boolean lot_tonnage int processing_tier enum [raw, cleaned, extract] hard gate licence_on_record
one plane two registries two score tool sets zero shared fields isolation forced at the row
§05the destination

Where this goes.

Finished, a pre-sales plane changes what the function is. Today pre-sales is a volume operation that occasionally produces a meeting. The end state is an instrumented judgement function: the company's belief about its own market, written down, versioned, continuously tested against outcomes — with a fleet of agents doing the reading, the reasoning and the reaching, and a human taking the chair the moment a human changes the outcome.

●None of the items below is a measured claim or a shipped feature list. This is the destination foxo is being built toward, stated as intent.

An ICP you can diff.

The definition of a good customer becomes a versioned artifact with a history. A quarter's win rate is attributable to a definition, not to a vibe — and when the market moves, you can see exactly which belief you changed and what happened next.

Research that compounds.

A fact learned about a market is stored once, with provenance, and reused by every agent and every tenant entitled to see it. The second question about an industry costs a fraction of the first, and the thousandth costs almost nothing.

Agents that sell against a product.

Not at a persona. The fleet reads the prospect's own product until it can argue value in the prospect's vocabulary — what their customers churn over, what their roadmap implies, where your thing lands inside their system.

A governor you can argue with.

Every hold, every suppression, every release is a replayable decision with a named rule. Change the rule, replay the week, and see what would have gone out differently. Policy stops being a memo and becomes executable.

The handoff as a first-class object.

A human does not inherit a summary. They inherit the reasoning chain — every claim, its source, its confidence, the rules that cleared it, and the exact sentence that made the prospect lean in.

Pre-sales as an audited function.

The day a board, a regulator or a customer asks why that person was contacted, with that claim, on that day — the answer is a query, not an investigation.

§06the operating ethic

Silence is a failure.

A plane that governs judgement has to be louder about its own faults than about its successes. These are not features. They are the rules the system is built under, and each one exists because its absence already cost us something.

RULE 01

A failed call logs at error.

Never at info. A credential that expires quietly is a fleet that stops working while every dashboard stays green.

RULE 02

"Never run" says never run.

An agent that has never executed does not report "ready". Absence of evidence is displayed as absence, not as health.

RULE 03

One record per action.

No sampling, no aggregation at the point of capture. If it happened once, it is in the record once, and it is findable.

RULE 04

Status is a surface.

Red or green is an endpoint, not a log grep. Nobody should have to read output to know whether the thing is alive.

RULE 05

Fail closed, by name.

An unresolvable source fails and says which source. It never falls through to an ambient credential or a plausible default.

RULE 06

Config, not code branches.

Tenant-variable behaviour is declared configuration. A new tenant is a new declaration, not a new conditional in shared code.

Observability here is not a tab. It is the reason the rest of the system can be trusted with an outbound action at all — a governor whose decisions you cannot read is just a delay.

The foxo thesis

the architecture of a governed pre-sales plane — the typed registry, the score tools, the provenance model, the gate.

Read it →
the judgement is the product

Declare what you believe. Let the fleet carry it.

The models will change. The channels will change. The agents are spawned and retired by the hour. What survives — and what compounds — is the declaration.

Enter the console → Read the thesis