XACT FOUNDRY

Xact Foundry turns natural-language intent into governed, deterministic agent capabilities—where ChatGPT understands, Xact decides, and consequences stay under explicit control.

Comment

Xact Foundry: Open-Ended Understanding. Governed Execution.

Inspiration

Most enterprise tools have to be anticipated and built in advance. Xact Foundry asks a different question:

What if a worker could describe the WebMCP Tool they need, and the system could safely build it on the spot?

A worker can simply say:

"Show urgent work orders that have no available qualified owner, ordered by due time."

ChatGPT acts as the conversational Boss. It interprets the request and can propose a structured capability.

But understanding is not authority.

Deterministic X-Nodes decide whether that proposal qualifies to become a governed WebMCP Tool. The Boss can clarify and reason, but it cannot override Xact.

The Boss determines what you mean. Xact determines what may become real.

What We Built

Xact Foundry turns ordinary human intent into governed WebMCP Tools.

Instead of requiring thousands of prewritten natural-language intent patterns, Xact works from a governed business vocabulary: customers, support cases, work orders, owner availability, due time, escalation eligibility, credit history, evidence freshness, permitted operations, roles, confirmation requirements, and authority boundaries.

The architecture is:

Stable governance primitives
            ↓
Reusable governed business vocabulary
            ↓
WebMCP Tool compositions

A request can resolve to five outcomes:

  • ALREADY_GOVERNED --- Xact already knows the composition.
  • COMPOSABLE --- the exact tool is new, but every required component is governed.
  • NEEDS_RESOLUTION --- a genuine semantic question remains, so the Boss asks for clarification.
  • NOVEL_BOUNDARY --- Xact understands the request, but the governed vocabulary does not yet support part of it.
  • UNAUTHORIZED --- the request is understood, but the required authority does not exist.

The Boss proposes structure. Xact has the final say.

Why WebMCP

WebMCP gives websites a structured way to expose capabilities directly to agents.

Xact Foundry explores what happens when those WebMCP Tools do not all have to be manually anticipated and built ahead of time.

A worker describes what they need. ChatGPT interprets it. Xact determines whether it can be constructed from governed business concepts. If it qualifies, Xact builds the governed WebMCP Tool. If it does not, Xact fails closed.

And building a tool is not permission to use it consequentially.

Permission to construct a tool is not permission to execute it.

A consequential runtime action still requires fresh Xact authority and an explicit Commit.

In short:

WebMCP provides capability. Xact provides authority.

The Hard Part: Evidence Is Not Authority

The hardest part was not making successful requests work. It was making ambiguous and unsafe requests fail truthfully.

During testing we found cases where:

  • "escalated" could be mistaken for an instruction to escalate;
  • "owner unavailable" could be mistaken for a reassignment request;
  • "service credit" in an evidence view could be mistaken for a credit mutation; and
  • historical or possible actions could be mistaken for requested actions.

We turned those failures into regression tests and reusable governed business concepts.

That led to a core invariant:

A consequence mentioned as history, eligibility, evidence, policy evaluation, hypothetical outcome, or a possible next action never implies intent or authority to perform that consequence.

Or more simply:

Evidence about a consequence is not authority to cause that consequence.

Governed Self-Service for the Enterprise

The larger vision is employee self-service without uncontrolled agent authority.

Instead of IT trying to anticipate every report, workflow, and agent tool employees may need, a company can govern its business vocabulary, data boundaries, roles, operations, and authority rules.

Workers then describe the combinations they need in ordinary language.

Some requests resolve immediately. Some can be safely composed. Some need clarification. Some require new governance. Others are understood perfectly and still refused.

Give workers freedom to ask for what they need without giving agents freedom to do whatever they want.

In a production deployment with authenticated identity and durable audit storage, the architecture can preserve evidence of who requested a capability, what was built, who invoked it, what was authorized, what was committed, and whether the consequence was verified.

How We Built It

Xact Foundry uses TypeScript, React, Model Context Protocol, an OpenAI Apps SDK-compatible MCP surface, and a public Sites deployment.

The demo uses fictional, public-safe business data rather than claiming a production CRM or ticketing integration.

To make the workflow easy to explore, we also created a set of pre-made example requests that users can run directly. These are not canned responses or separate demo paths. They are realistic business requests designed to exercise the same Foundry pipeline a user's own request would use.

The examples let a first-time user quickly experience different behaviors: an already-governed tool, a newly composable tool, a read-only evidence view, a request requiring clarification, and a request Xact must refuse. After seeing the workflow, users can simply write their own request in ordinary language.

The control flow is the same for both the example requests and custom requests:

Human intent
    ↓
ChatGPT / Boss
    ↓
Structured proposal
    ↓
Xact resolution
    ↓
Clarify or compose
    ↓
Validate
    ↓
Authorize construction
    ↓
Commit
    ↓
Build WebMCP Tool
    ↓
Observe and verify

------------------------------------------------------------------------

## What We Learned

The biggest lesson was that open-ended understanding does **not**
require open-ended authority.

We also learned that reusable governed business vocabulary scales better
than thousands of prompt-specific rules. When a novel composition is
validated, governed, and activated, future requests for that composition
can take the deterministic **ALREADY_GOVERNED** path.

That creates a governed learning loop:

> **Reasoning discovers. Governance approves. Xact absorbs.**

Reasoning can reduce the future need for reasoning without giving the
reasoning model authority to expand its own permissions.

------------------------------------------------------------------------

## The Proof

Already-governed capabilities can resolve and construct with **zero LLM
inference tokens**.

In a browser benchmark, **10,011 deterministic construction operations**
were exercised with parallel execution reaching approximately **6.1×
speedup** while preserving a **bit-identical checksum**. Parallelism
changed speed, not the result.

Separately, the reference Xact implementation measured approximately **9
microseconds mean decision latency** on a single CPU. That is a
reference measurement, not a claim about the live browser demo.

The important idea is not simply that deterministic execution can be
fast:

> **The language model does not need to sit in the middle of work that
> has already become exact.**

------------------------------------------------------------------------

## The Vision

Xact Foundry changes the enterprise tool model from:

> **Build every tool someone might need.**

to:

> **Govern what may be built, then let workers describe what they
> need.**

**ChatGPT provides open-ended understanding. WebMCP provides structured
capability. Xact determines what qualifies to be built and what is
authorized to become consequential.**

## Built Around Your Business

No two businesses operate exactly alike. Their data models, workflows,
roles, policies, terminology, and backend systems are different.

That is where the combination of **Xact Foundry and WebMCP becomes
especially powerful**.

Instead of forcing every company into a predefined set of tools, an
organization can give Xact a governed description of its business:
the resources that exist, what they mean, the approved connection
points, who may access them, and what actions are permitted.

WebMCP provides the structured connection to those capabilities.
Xact provides the governed construction and authority layer around them.

Once that foundation exists, workers do not need developers to anticipate
every useful combination in advance. They can describe what they need
in ordinary language, and Xact can determine whether that capability
can be safely constructed from the company's own governed business
vocabulary.

> **Your business defines the vocabulary. WebMCP connects the capabilities.
> Xact governs what may be built and what may become consequential.**

The result is not one generic toolset for every company. It is a Foundry
that can adapt to the shape of each business without relaxing the
boundaries that business has established.

> **Reason when necessary. Execute Xactly.**

Built With

  • cloudflare-d1
  • cloudflare-sites
  • cloudflare-workers
  • custom-deterministic-system
  • git
  • github
  • javascript
  • json-rpc
  • model-context-protocol-(mcp)
  • next.js
  • node.js
  • openai-apps-sdk
  • openai-chatgpt
  • react
  • rest-apis
  • typescript
  • vinext
  • vite
  • webmcp
  • zod
Share this project:

Updates