The first runtime

WAR — the WeSimplifAI Agent Runtime

Stop prompting. Start building.

WAR is an intent-native runtime. Natural language touches exactly one component; everything a person means is captured into the Intent Graph — typed, versioned, language-free and hash-verifiable. Downstream of that graph, planning, composition and compilation are deterministic. Prompts appear only inside per-provider compilers, so the same intent runs on any AI model against identical contracts.

The architecture described on this page is specified at RFC-2119 grade and is pre-prototype. What runs in production today is in the right-hand column of Specified versus running, below.
The architecture

The determinism boundary

Above the line, understanding is probabilistic and contract-bound. Below it, everything is a deterministic function of the graph, given pinned versions.

Above the line — probabilistic, contract-bound

Human intentany language · voice · canvas
What a person actually wants, before anything has translated it.
Intent Understanding LayerIUL
The only component permitted to see language.
SPECIFIEDrow 2
Nondeterminism ends here
Intent GraphWAR-IR
Typed, event-sourced, language-free. This is the object the rest of the runtime computes on.
SPECIFIEDrow 1
Plannerpure function
Same graph in, byte-identical plan out.
SPECIFIEDrow 3
Capability Composerversioned capabilities
A deterministic closure over the capability packs a plan needs.
SPECIFIEDrow 4
Provider Compilerone per provider
Prompts appear here for the first time — as a serialization format, not as the program.
SPECIFIEDrow 4
Any AI modelClaude · Gemini · …
Verified artifacts, plus the decision records that explain them.
LIVErow 15

Below the line — deterministic, replayable

The WAR determinism boundary. Stages marked SPECIFIED are written at RFC-2119 grade and are pre-prototype.
The mechanisms

Five mechanisms and their enforcement

The enforcement column is the point. A property without an enforcement is an adjective.

MechanismEnforcementStatus
Language-free canonical representation The core graph may contain no natural-language prose. Specified as an automated lint pass, not a convention: human-facing text lives in a display sidecar keyed by locale, and deleting every sidecar leaves a functional graph.
SPECIFIED
row 1
A determinism boundary Replaying the operation log is specified to reproduce the content hash exactly. The planner is specified as a pure function. The specification itself flags this as its riskiest promise, which is why it is written down rather than asserted.
SPECIFIED
row 3
Provider independence as structure Only compilers know provider quirks; adding a provider is specified to touch nothing upstream. Claude and Gemini are swapped live by configuration today, with no capability-specific code.
SPECIFIEDLIVE
row 4 · row 15
Explainability by construction Every non-obvious choice produces a decision node — chosen, alternatives, consequences. Narration is rendered from those objects, never free-generated. The audit trail, the debugger and the demo are specified as one feature.
SPECIFIED
row 6
Never guess silently Ambiguity is specified as a first-class typed object with a taxonomy. Missing meaning becomes a ranked, budgeted question in the person's own language. Defaults are recorded and revisitable.
SPECIFIED
row 5
One rule is not yet enforced. The pivot-language verification harness — the CI test that would prove intent authored natively in different languages produces semantically identical graphs — is designed and is not in CI (row 8). There is therefore no multilingual determinism demonstration anywhere on this site. A language is only "supported" once it clears that harness.
The honest split

Specified versus running

Two columns, because they are two different things, and conflating them is the failure mode this whole site is built to avoid.

SPECIFIED

Specified · pre-prototype

Written at RFC-2119 grade, to be implementable without the authors present. Not running.

Intent Graph — typed, event-sourced, hash-verifiable, language-free row 1
Intent Understanding Layer — the seven-stage pipeline row 2
Deterministic planner — pure function, byte-identical replay row 3
Provider compilers — cross-model replay, mid-execution fallback row 4
Clarification Engine — taxonomy, budget, why-carrying questions row 5
Build Along™ — blast radius, interruption, rendered narration, replay row 6
WAR-TRACE-001 — a complete worked trace on paper, not an execution log row 7
Pivot-language verification harness — designed, not in CI row 8
LIVE

Running in production today

Verified 3 August 2026. Everything in this column may be described in the present tense.

CP-001 Business Website — executes on the WAR runtime row 13
CP-002 Company Research Brief — executes on the WAR runtime row 14
Claude ↔ Gemini provider swap by configuration, no capability-specific code row 15
Research discipline — doctrine governance, self-critiquing specifications row 9
Enterprise Context Intelligence is the first enterprise application of the WAR architecture and its commercial validation pathway. It does not run on WAR — row 10. That is also why there is no Enterprise section in the navigation of this site.
Category gravity

What WAR is, and what it is not

Every new category gets pulled toward the nearest familiar one. This list exists so the pull is resisted explicitly rather than argued about later.

WAR is

  • An intent runtimeThe layer between a person's intent and any AI model.
  • The first implementation of Intent-Native ComputingIntent, not language, as the unit of computation.
  • A determinism boundaryNondeterminism ends at the Intent Graph. Everything downstream is a pure function of it.
  • Language-independent by designThe graph never remembers what language the intent arrived in.
  • Provider-agnostic by constitutionThe best model for the task, never a captive one.
  • Domain-agnostic at its coreCoding is the first plugin, not the definition.
  • A capability platformVersioned, conformance-tested units of business function.
  • A transparent software construction engineConstruction is narrated, not hidden.
  • Observable by constructionEvery binding decision exists as an inspectable object, not a log line.
  • Built for the verifier who is not an authorThe founder's check and the engineer's check are one graph at two altitudes.

WAR is not

  • Another AI IDE or coding assistant
  • Another prompt editor or LLM wrapper
  • A single-provider product
  • A translation product
  • An observability dashboard beside a black box

The full eleven-item fence — including the explainable-AI and model-interpretability guardrails — is kept in llms-full.txt. It is shortened here, not abandoned.

The handoff

This page describes the runtime.

If you want to use it, that is a different site — and deliberately so. wesimplifai.com exists to be checked; war.wesimplifai.com exists to be built with.

Stop prompting. Start building.

Try WAR ↗ Check the claims