# NOUSIA-23

![NOUSIA-23 turns language into a verified semantic lattice and then into software and governed tool actions](assets/nousia-23-defining-image.png)

**A deterministic synthetic transpiler for natural language, typed intent, proof-gated synthesis, and governed tool use—without a neural runtime.**

NOUSIA-23 is the standalone successor to Project 33. It occupies a role that was previously assigned to Qwen3-0.6B in the Polar Pyro TaskIntent pipeline: convert a user's request into stable, machine-checkable meaning for DEMIURGE and specialist engines. Its decisive difference is architectural. It does not sample tokens or load model weights. It parses, constrains, enumerates, collapses, verifies, and emits canonical receipts.

The achievement is not that every English sentence has become formally decidable. It is that a production software-intent lane can replace a neural proposer with an inspectable compiler, produce equal inputs byte-for-byte, fail closed on ambiguity, and expose the same deterministic core to any host through Python, JSON CLI, HTTP, or MCP.

## What it guarantees

- Identical admitted input plus identical capability catalog produces identical canonical output.
- Every service response binds the request and result to SHA-256 material.
- Unsupported or underdetermined meaning becomes `NO_RESULT` or a clarification residual—not invented intent.
- Core installation has no third-party dependency and the production package imports no neural runtime.
- The compiler has no execution authority. Tool effects remain the responsibility of a separately governed host.
- MCP registration does not grant arbitrary capability: manifests must define schema, authority, effects, evidence, scope, timeout, and oracle.

## Architecture

```text
English / Task request
        │
        ▼
 normalization → parsing → semantic candidates → constraint propagation
        │                                │
        │                      ambiguity/residuals ──► questions
        ▼
 canonical Semantic IR / TaskIntentIR
        │
        ├──► Euclid-Ω: proof, planning, counterexample, refinement
        ├──► DEMIURGE: artifact composition and synthesis
        └──► MCP host: governed observation/effect capabilities
                         │
                         ▼
              independent oracle + canonical receipt
```

NOUSIA-23 determines what an admitted request can mean. Euclid-Ω determines what follows from a formal candidate. MCP supplies governed observations and effects. DEMIURGE composes artifacts. Independent oracles determine whether the output satisfies the contract.

## Four stable interfaces

### Python

```python
from nousia23 import Nousia23

receipt = Nousia23().execute(
    {
        "operation": "compile_task_intent",
        "request_id": "demo-001",
        "payload": {
            "project_id": "polar-pyro",
            "prompt": "Build an accessible inventory dashboard with audit history",
        },
    }
)
assert receipt["neural_calls"] == 0
```

### JSON CLI

```bash
python -m pip install -e .
echo '{"operation":"capabilities","payload":{}}' | nousia23
```

Exit codes are `0` for `PASS`, `3` for `NO_RESULT`, and `2` for `FAIL`. Standard output contains exactly one canonical JSON receipt.

### HTTP

```bash
python -m pip install -e ".[http]"
uvicorn nousia23.http:create_app --factory --host 127.0.0.1 --port 8080
curl http://127.0.0.1:8080/v1/capabilities
```

The service exposes `GET /health`, `GET /v1/capabilities`, and `POST /v1/execute`. The Docker image runs as an unprivileged user.

### MCP

```json
{
  "mcpServers": {
    "nousia-23": {
      "command": "nousia23-mcp",
      "args": []
    }
  }
}
```

The dependency-free stdio server implements MCP `2025-06-18` initialization, tool discovery, tool calls, and ping. Its four tools are read-only compiler functions: interpret, open-domain grounding, TaskIntent compilation, and independent TaskIntent verification.

## Operations

| Operation | Input | Output | Boundary |
|---|---|---|---|
| `interpret` | controlled English + context | checked packed Semantic IR | unknown constructs fail closed |
| `compile_open_domain` | unrestricted Unicode + closed catalog | grounded capabilities, spans, residuals, questions | open input is not universal understanding |
| `compile_task_intent` | software request + project identity | Polar Pyro TaskIntentIR | admitted grammar and ontology |
| `verify_task_intent` | source request + candidate IR | independent replay receipt | candidate cannot self-certify |

Machine-readable contracts live in [`schemas/`](schemas/). The normative human specification lives in [`docs/specification/`](docs/specification/).

## Memory and context

NOUSIA-23 has no transformer context window. It can address a virtually unbounded external corpus through TOAM or another content-addressed store, but computation is deliberately bounded. Every proof/search workspace has explicit budgets, provenance, and eviction rules. The accurate promise is **unbounded addressable memory with bounded, auditable working sets**, not magical infinite simultaneous context.

## Qualification

```bash
python -m pip install -e ".[dev,http]"
python -m ruff check .
python -m ruff format --check .
python -m mypy src
python -m pytest --cov=nousia23 --cov-report=term-missing --cov-fail-under=80
python scripts/audit_neural_runtime.py --require-zero
python scripts/qualify_task_intent.py
python scripts/qualify_algorithm_portfolio.py
python -m build
```

The inherited Project 33 qualification demonstrated exact TaskIntent parity against a frozen Qwen reference lane for the admitted corpus and zero recorded neural calls. Those results are a bounded substitution claim, not proof of unrestricted frontier-model equivalence. NOUSIA-23 treats broader superiority as an empirical program: frozen contracts, held-out corpora, adversarial paraphrases, behavioural artifact oracles, latency/resource measurement, and a mandatory zero-neural-call detector.

The fresh standalone certificate records **119/119 tests, 83.85% branch-aware coverage, strict typing across 29 source files, 37/37 frozen TaskIntent cases, and zero neural-runtime findings**. See [the qualification record](docs/qualification/QUALIFICATION_2026-08-23.md).

## Repository map

```text
src/nousia23/       deterministic compiler, IR, reasoners, service transports
schemas/            versioned JSON interface and capability contracts
benchmarks/         frozen, reviewable qualification corpora
scripts/            qualification and neural-runtime audits
tests/              unit, property, regression, transport, and parity tests
docs/specification/ normative multi-document system specification
assets/             defining project artwork
```

## Claims and limits

NOUSIA-23 can be superior to a neural model where determinism, auditability, latency, reproducibility, formal contracts, and fail-closed behaviour are the governing metrics. It does not currently claim universal conversational equivalence, unconstrained world knowledge, or proof of correctness for every English utterance. Internet research is possible only when a host registers scoped search/fetch tools and their evidence oracles; the compiler itself performs no covert network access.

Start with the [product constitution](docs/specification/00_PRODUCT_CONSTITUTION.md), [architecture](docs/specification/01_SYSTEM_ARCHITECTURE.md), and [interface contracts](docs/specification/02_INTERFACE_CONTRACTS.md). The [claims ledger](docs/specification/CLAIMS_LEDGER.md) separates demonstrated facts from targets.

## License

MIT. See [LICENSE](LICENSE).