The business compiler has six structural advantages. All of them are running.
Wovia turns a description of a business into an operating system of
self-connecting nodes. These aren't roadmap claims — every mechanic below is
shipped engine code or a proven spike, with the real numbers attached.
268 tests greenbuild phases 0–5 shippedmatching bands calibrated on real geometrymodels pinned + hash-verified
↓ the mechanics
01DESCRIPTOR DOUBLE-DUTY
One declaration powers matching and execution.
Every field in a Wovia manifest carries a plain-language
descriptor. That single sentence does two jobs at once: it's the meaning
the mesh uses to wire data flows semantically (no brittle key mapping),
and it's the field description an AI model reads to extract or generate that
exact field. Adding a business vertical means writing descriptors —
matching and execution both come free. Competitors configure these twice,
per integration, forever.
→ becomes the extraction schema
applicant_name: { type: string, description: "legal name of the license applicant" }
applicant_name: "legal name of the license applicant"
ONE LINE IN THE MANIFEST
→ becomes the semantic binding
parser#out/applicant_name ⇄ cosine 0.94, margin 0.14 compliance#need/applicant_name BOUND — by meaning
rename a field, reword a descriptor — the mesh re-binds itself. Nothing breaks downstream.
proven: engine spike, schema derived verbatim from ports, values bound downstream — same descriptors
02TOKEN-LEVEL PIPELINING
Agent chains that stream, not queue.
Every agent framework on the market passes whole messages
between steps — step two waits for all of step one. Wovia's data plane was built
streaming-first: nodes hand off token by token, so a drafting node's prose
flows into formatting and delivery while it's still being written. Latency
stops stacking per hop.
everyone else — request / response total wait: Σ steps
draft
format
deliver
wovia — streaming frames first output: ~immediately
draft
format
deliver
shipped: frame-level relay forwarding, watermark backpressure, live since the first engine build
03AGENTS AS COMPILED DATA
The node's persona is the agent.
In Wovia, an AI agent isn't hand-built — it's compiled from
the same manifest that defines the business. The node's persona seeds the
agent's instructions; its skills, tools and quality bar are data fields. Version
the manifest, version the agent. And because the agent's configuration is data,
it belongs to the customer — it exports with their OS.
application-parser v3
system ← persona · tools ← allowlist
rubric ← validation blocks owned by the tenant. exports with them.
specified: EXECUTION_SPEC §3.3 — compilation target under ratification
04VALIDATION IS THE RUBRIC
"Done" is defined in data — the engine never guesses.
Manifests already declare what a valid output looks like.
Pointed at agent work, the same declaration becomes the grading rubric of an
iterate-until-it-passes loop: draft, grade against the manifest's own
validation, revise. Quality criteria live with the business definition — not
buried in prompts, not hard-coded, auditable by the customer.
draft
grade · revise
rubric =validate:{ the manifest'sown rules }
The loop exits only when the output passes the declared bar.
Fail-closed: work that can't meet the bar is surfaced, never silently shipped.
Every capability runs as a ladder: try the deterministic
template, escalate to a single model call, reserve the full agent
for the hard residue. The ladder itself is manifest data — tuned per vertical,
per tenant, without code. The engine already runs this pattern in production
for ambiguity resolution: a local reranker decides in ~10ms, a local LLM takes
the residue, the frontier model is the last resort — and a miss fails closed,
never guesses.
tier 1 · template
~free · most work
tier 2 · one model call
cents · residue
tier 3 · full agent
$ · hard cases
shipped today: the resolver waterfall (cross-encoder → tiny LLM → frontier) — same pattern, running, audited per tier
06LEARNING AS CACHED DATA
Every tenant's OS gets cheaper with use.
The first time the system meets a recurring artifact — the same
state form, every application — it pays for intelligence. The mapping it learns
is cached as data, so the second encounter runs at the cheap tier. Unit
economics improve per tenant, automatically, forever. And because the learning
is data, it exports with the customer — their operational experience is
theirs, which is a sales weapon disguised as an architecture choice.
1st
2nd
3rd
4th
5th
nth
cost per encounter of a recurring artifact — learned layout served from cache
pattern shipped today as the route cache (zero-inference warm starts, persisted); execution analogue specified in §3.6
Not a deck. A repository.
268
tests green, security suite included — tenant isolation proven adversarially
0.80
semantic bind threshold — calibrated against real embedding geometry, not guessed
~10ms
ambiguity resolution, tier 1 — deterministic, local, no prompt to inject
1
store per sovereign instance — a customer's OS exports as data they own
next on beep
Play with the actual matcher.
The same embedding model the engine pins runs in your browser. Type two
field descriptions, watch the real cosine score and the real bind/escalate
decision — the moat, in your hands. Coming to this page.