nous-lang 5.74.1

NOUS (Νοῦς) — The Living Language for Agentic AI Systems

NOUS (Nous) -- The Living Language

An agentic programming language with end-to-end formal cost-bound verification, in any currency the pricing table declares, with cryptographically signed dossiers anchored to a public transparency log and verifiable by anyone offline.

  _   _  ___  _   _ ____
 | \ | |/ _ \| | | / ___|
 |  \| | | | | | | \___ \
 | |\  | |_| | |_| |___) |
 |_| \_|\___/ \___/|____/   v5.73.1

Author: Hlias Staurou (Hlia) | Project: Noosphere | GitHub: contrario/nous | Website: nous-lang.org

What is NOUS?

NOUS is a programming language for agentic AI systems where every program is:

• Verifiable -- declare a cost_cap in USD or EUR and Z3 proves at compile time that no execution path can ever exceed it.
• Auditable -- every verified program emits an Ed25519-signed manifest with full provenance (source SHA-256, AST SHA-256, pricing SHA-256, SMT obligations SHA-256, solver name+version, verdict, timestamp).
• Annex IV-ready -- nous dossier emits an EU AI Act Annex IV-aligned compliance bundle directly from the AST plus the signed manifest plus the pricing table.
• Rekor-anchored -- since v5.3.0, optional --anchor rekor anchors emitted manifests into the public Sigstore Rekor transparency log via Path-beta dual signing (per-submission ECDSA-P-256 leaf, long-lived Ed25519 manifest signature preserved). Since v5.10.0 a Rekor v2 path (--anchor rekor_v2) targets the tile-backed Sigstore log with an RFC 3161 trusted timestamp over the leaf signature, all re-verifiable offline. External, third-party-auditable durability, with no NOUS-side trust assumption on the offline verification path. See docs/REKOR_ANCHOR.md and docs/REKOR_V2_MIGRATION.md.
• Publicly verifiable -- since v5.4.0, any signed dossier can be verified by anyone via three independent paths: POST /api/v1/verify-dossier (browser convenience, no API key, rate-limited), verify_offline.py (canonical, single cryptography dependency), or nous dossier verify (full toolchain with SMT cost-cap re-check). See docs/VERIFY_DOSSIER.md.
• Governable -- first-class policy { on ... signal ... action ... } declarations, statically lintable (13 rule codes) and live-simulatable.
• Deterministically replayable -- every agent run produces a SHA-256-chained JSONL event log. nous replay verify validates chain integrity offline.
• Self-evolving (opt-in) -- nous evolve mutates a program's declared DNA genes within their declared ranges on a shadow copy of the AST, re-validates each candidate against the constitutional law checker, and keeps a mutation only if a measured fitness score improves -- otherwise it rolls back atomically. Optimization within declared bounds; it records each mutation and proves nothing.
• Governed and evidenced -- beyond cost proofs, NOUS emits a lineage of signed, offline-verifiable evidence artifacts: runtime-conformance certificates, materiality classification, gated-action authorization, an append-only continuity and envelope ledger with witness cosignatures, per-interval closure attestations, a SLSA Verification Summary Attestation with published conformance vectors, and consume-only adapters for third-party governance frameworks. Each EVIDENCES within a declared boundary (see Documentation); none is a runtime guard.

NOUS transpiles to Python 3.11+ asyncio. The toolchain is a single PyPI package -- no Java, no Docker, no LangChain / LlamaIndex / CrewAI dependencies.

The honest boundary

NOUS is a monitor, not a guard: policies and evidence surfaces record and attest, they do not enforce at runtime. The word proves is reserved strictly for the Z3/Farkas legs -- the cost-cap bound, policy-coverage, and sequence-ordering. Everything else -- Ed25519/ML-DSA signatures, Rekor v2 inclusion, RFC 3161 timestamps, continuity/envelope/witness cosignatures, closure attestations, and every interop adapter -- evidences, it does not prove. Name-to-key binding is operator-asserted; NOUS runs no CA and certifies no identity. Independent witnessing is staging, genesis-only. The interop adapters (Santander mech-gov, Guardrails AI, LLM Guard) are consume-only over synthetic/benchmark inputs, not production usage. Each artifact's exact claim class and boundary is stated in the Documentation section.

Why this matters

Runtime budget caps abort only after the spend has already happened. NOUS instead proves before execution, across every reachable path, that total cost cannot exceed the declared cap -- a Z3/Farkas result, not a runtime check. The cost model is auditable (signed pricing TOML with SHA-256), and the artefact (signed manifest) is verifiable by anyone holding your public key -- making it directly useful for EU AI Act Annex IV / Article 11(1) technical documentation.

With v5.3.0 Rekor anchoring and v5.4.0 public verification surface, the trust model is closed end-to-end: third-party auditors no longer need the NOUS CLI to validate a dossier. A regulator, journalist, or compliance officer can drag a manifest into nous-lang.org/verify and see three independent PASS/FAIL pills in their browser, or run verify_offline.py on an air-gapped machine. The cryptographic chain extends from your build pipeline to a public transparency log to anyone holding a copy of the dossier.

Install

# Core toolchain (cryptography is base, not optional)
pip install nous-lang

# With SMT cost-bound verification (adds Z3)
pip install 'nous-lang[smt]'

# With LSP server (VS Code / editor diagnostics)
pip install 'nous-lang[lsp]'

# Everything
pip install 'nous-lang[all]'

Requirements: Python 3.11+. The [smt] extra pulls z3-solver. cryptography (used for Ed25519 signing) is a base dependency since v4.17.0.

60-second quick start

# 1. Initialise a project
mkdir my_world && cd my_world
nous prices init                       # writes ./nous_prices.toml from defaults
nous templates extract cost_cap_basic  # copies a working .nous program

# 2. Verify formally
nous verify cost_cap_basic.nous --smt
# -> Verdict: PROVEN. Manifest written to cost_cap_basic.manifest.json.

# 3. Emit an Annex IV compliance dossier
nous dossier cost_cap_basic.nous
# -> bundles source, AST, manifest, pricing table, and Annex IV mapping

# 4. (Optional) Anchor the dossier into the public Sigstore Rekor log
nous dossier cost_cap_basic.nous --anchor rekor
# -> manifest gains a transparency_log block with log_index + integrated time

# 5. (Optional) Verify a dossier offline (no NOUS install required for the verifier)
python3 verify_offline.py cost_cap_basic.dossier.json
# -> PASS / FAIL on Ed25519 signature, source SHA, Rekor inclusion, ECDSA-P-256 SET

For EUR end-to-end verification, point --prices at an EUR pricing table:

nous verify --smt my_eur_agent.nous \
    --prices /path/to/eur_prices.toml

The shipped pricing/eur_example.toml declares four illustrative Mistral models priced in EUR per 1 000 000 tokens. Values are explicitly marked illustrative; verify against the provider before any production use.

Core CLI

nous run file.nous              # compile + execute
nous compile file.nous          # -> Python file
nous verify file.nous           # governance lint as build gate
nous verify file.nous --smt     # SMT cost proof + signed manifest
nous verify file.nous --smt --smt-margin 10
                                # prove total_cost <= cap * 90/100
nous verify-cost cost.farkas.json
                                # offline re-check of the cost-cap Farkas cert (no solver)
nous emit-smt file.nous         # SMT-LIB 2.6 source (re-usable across solvers)
nous dossier file.nous          # EU AI Act Annex IV compliance bundle
nous dossier file.nous --anchor rekor
                                # also anchor manifest into Sigstore Rekor
nous dossier verify <path>      # offline re-verification of a dossier

nous prices show                # active layered pricing table + SHA-256
nous prices init                # write nous_prices.toml in cwd
nous prices verify <model>      # detailed cost breakdown for one model
nous prices age                 # staleness report across all entries
nous prices upgrade <file>      # migrate v1.0 -> v2.0 schema (preserves comments)

nous governance lint file.nous  # static analysis (13 rule codes)
nous governance simulate ...    # what-if policy evaluation

nous replay verify <log>        # validate JSONL chain integrity
nous replay diff a.jsonl b.jsonl
                                # lockstep event-level diff

nous templates list             # list bundled templates (9 shipped)
nous templates show <name>      # print template source to stdout
nous templates extract <name>   # copy template into a directory

nous skill export file.nous     # emit agentskills.io-compatible skill folder
nous dossier-spec ./my-skill/   # emit signed Annex IV dossier from SKILL.md

nous lsp                        # start LSP server (stdio)
nous version

The full nous --help lists 62 top-level subcommands; the above covers the most-used surface.

Language at a glance

world ExampleWorld {
    cost_cap: 1.00 USD              // formal SMT bound, USD or EUR
    max_ticks: 10                   // bound on heartbeat cycles
    law CostCeiling = $0.10 per cycle
    law MaxLatency = 30s
    law NoLiveTrading = true
}

soul Sentinel {
    mind: claude-opus-4-7 @ Tier1
    tokens: input=1000 output=400   // SMT input
    senses: market_feed, risk_oracle
    speaks: AlertChannel
    remembers: last_signal
}

policy on llm.response signal contains_phrase("absolutely") action log_only weight 0.3

Architecture

Layer	Implementation
Grammar	Lark LALR (nous.lark), bilingual EN+GR
AST	Pydantic V2 strict models
Validator	Constitutional law checker on AST
Pricing	Layered TOML (CLI > project > user > package), SHA-256 audit, schema v2.0, currency-agnostic
SMT emit	Deterministic SMT-LIB 2.6, exact rationals (no floats)
SMT solve	Z3 wrapper + counterexample extraction + fix suggestions
Manifests	Ed25519-signed JSON, manifest schema v1.0, offline-verifiable
Rekor anchor	Optional Path-beta dual signing (ECDSA-P-256 leaf + Ed25519 manifest)
Verify API	POST /v1/verify-dossier public endpoint, granular three-path response
Dossier	EU AI Act Annex IV-aligned compliance bundle from AST + manifest
CodeGen	AST -> Python 3.11+ asyncio
Replay	SHA-256-chained JSONL event log, integrity-verifiable offline
Runtime	asyncio event loop + Noosphere integration
LSP	stdio JSON-RPC, lint diagnostics with source="nous.lint"

The signed-manifest contract

When nous verify --smt returns PROVEN, it writes a JSON manifest:

{
  "schema_version": "1.0",
  "nous_version": "5.11.0",
  "smt_emit_version": "...",
  "source_path": "trading.nous",
  "source_sha256": "...",
  "ast_sha256": "...",
  "pricing_sha256": "...",
  "smt_obligations_sha256": "...",
  "solver": "z3",
  "solver_version": "...",
  "verdict": "proven",
  "cost_cap": "0.50",
  "currency": "USD",
  "timestamp": "2026-05-17T12:34:56Z",
  "signature": "<base64 ed25519>",
  "public_key": "<base64 ed25519 pubkey>",
  "transparency_log": {
    "rekor_log_index": 1554376230,
    "rekor_integrated_at": "2026-05-16T20:08:25Z",
    "rekor_log_id": "...",
    "submitter_public_key_b64": "...",
    "submitter_signature_b64": "..."
  }
}

The transparency_log block is present only when the dossier was emitted with --anchor rekor. Anyone with the manifest and the publisher's public key can re-verify offline. Tamper-detection is built in. If the manifest is Rekor-anchored, the inclusion proof and SignedEntryTimestamp can be re-validated independently against the public Sigstore log.

The verifier signing key lives at $XDG_DATA_HOME/nous/keys/signing.key (mode 0600, auto-generated; falls back to ~/.local/share/nous/keys/signing.key if XDG is unset; override with --key-path).

Public verification (v5.4.0+)

Three independent paths for third parties to verify a NOUS dossier without installing the NOUS toolchain:

1. Browser convenience: drag-drop the manifest into https://nous-lang.org/verify. Behind the scenes calls the public POST /v1/verify-dossier endpoint (no API key, rate-limited 30 req/min, 256 KiB body cap). Useful for compliance officers and journalists.
2. Offline canonical: download https://nous-lang.org/verify_offline.py (or extract from any anchored dossier). Runs locally; only dependency is cryptography>=42. No NOUS install, no internet required for non-Rekor checks, no network round-trip to NOUS infrastructure. This is the canonical trust path.
3. Full CLI: pip install nous-lang && nous dossier verify <path>. Re-runs SMT cost-cap verification in addition to signature and anchor checks.

Verification returns granular per-check results:

• signature_ok -- Ed25519 author signature over canonical manifest body
• rekor_set_ok -- Sigstore SignedEntryTimestamp + log-key allowlist
• rekor_inclusion_ok -- leaf body hash + ECDSA-P-256 submitter signature

See docs/VERIFY_DOSSIER.md for the full API reference, trust model, and failure-mode table.

EU AI Act compliance

NOUS targets EU AI Act conformity for the high-risk AI system requirements of Regulation (EU) 2024/1689. The compliance matrix lives in docs/EU_AI_ACT_COMPLIANCE.md. Current coverage: 8 of 10 mapped articles fully covered, 1 planned, 1 out of scope.

Key article alignments:

• Article 11 (Technical Documentation) -- nous dossier emits an Annex IV-aligned bundle directly from the AST.
• Article 12 (Record-Keeping) -- SHA-256-chained JSONL replay logs, integrity-verifiable via nous replay verify.
• Article 13 (Transparency) -- public verification endpoint and standalone nous-lang.org/verify page give downstream users a no-install path to independently audit any dossier.
• Article 14 (Human Oversight) -- intervene, inject_message, block policy actions plus governance simulator.
• Article 15 (Accuracy / Robustness / Cybersecurity) -- Z3 SMT proofs on every cost_cap declaration, currency-aware (USD + EUR), with Ed25519-signed manifests and optional Sigstore Rekor anchoring for tamper-evident durability.
• Article 17 (Quality Management) -- 10-phase release pipeline, 2494-test pytest floor, byte-identical regression harness.

Annex IV dossiers from existing SKILL.md skills (v5.1.0+)

NOUS can produce signed Annex IV dossiers directly from skill folders that follow the agentskills.io SKILL.md spec, without modifying the skill itself. Add a nous.yaml sidecar declaring cost_cap, default_model, and per-tool max_calls / input_tokens / output_tokens, then:

nous dossier-spec ./my-skill/

The resulting bundle contains the verbatim SKILL.md and nous.yaml, a deterministic source envelope (source.nous), the signed manifest.json, the resolved pricing TOML, the public key, a human-readable README, and an offline verify_offline.py. SKILL.md is left byte-identical, so strict spec validators continue to pass. See docs/SKILL_MD_SIDECAR.md for the schema reference and CLI flag documentation. For the inverse direction -- emitting an agentskills.io skill from a .nous program via CLI, HTTP API, or IDE button -- see docs/SKILL_EXPORT.md.

Documentation

• Cost Verification Guide -- end-to-end walkthrough for USD and EUR
• SMT Verification Design -- soundness contract, Z3 pin rationale
• Coverage Proof -- policy-coverage SMT obligation, Farkas certificate, stdlib-only offline verification
• VSA Conformance Vectors -- published frozen input/expected-output bundle; implementation-independent offline verification of the manifest canon, signatures, and cost/coverage Farkas verdicts (cryptography + stdlib, no solver)
• Memory Evidence Design -- signed per-soul memory, Phase 0 freeze
• Memory CLI -- nous memory init/append/verify/reindex reference
• Memory Phase 1 Design -- NAME-BOUND identity, drop-when-None write-path invariant, single-soul (Option c) freeze
• Memory Consultation -- consult per-(world,soul) memory inside the signed trace; offline-verifiable chain-head commitment
• EU AI Act Compliance -- Annex IV / Article 11 mapping
• Annex IV Mapping -- per-section Annex IV crosswalk to NOUS evidence artifacts
• Rekor Anchoring -- Path-beta dual signing, Sigstore wire format, offline verification
• Rekor v2 Migration -- migration plan from Rekor v1 to v2 (Sigstore tile-based log)
• Public Verification API -- POST /v1/verify-dossier, trust model, three verification paths
• SKILL.md Sidecar -- emit dossiers from existing agentskills.io skill folders
• Skill Export -- emit agentskills.io skills from .nous programs
• Runtime Conformance -- prove a signed execution trace stayed inside the static proof's envelope; standalone signed certificate, Rekor v2 anchor, offline verifier
• Sequence Laws -- declare ordering laws over an event alphabet; Z3 consistency proof (nous verify-sequence), the seventh runtime conformance obligation, schema-versioned certificate
• Gated Actions -- declare which actions require an approver attestation via law gated(<action>), optionally with an N-of-M quorum threshold law gated(<action>, K) requiring K distinct approving keys (multisig dual-control; Article 14(5) four-eyes as one instance, not a general claim); the gated set and threshold are signed-source-derived and tamper-evident, the completeness counterpart to conformance obligation #5
• Materiality Classification -- classify a change minor vs material against a prior source build (nous verify --materiality-against); the verdict is carried as a sha-pinned materiality.json sidecar in the signed manifest and dossier, authenticated offline by the dossier verifier, which routes a material change toward the envelope-binding proof leg. The verdict is a classification that EVIDENCES, never a proof.
• Authorization Runtime -- the gated-action decision surface (approve/deny/override) for Article 14(4)(d) human oversight; a signed, verb-bound AuthorizationAttestation evidences that a named principal recorded a decision, with refusals folded into the signed preimage and the exception/escalation record being the non-approved subset; evidences the decision was recorded, not that it was correct or meaningful
• Decision Ledger -- a presentation view over a signed trace's recorded decisions (approve/deny/override distribution, principal diversity, time spread) plus a per-gated-action quorum section (one row per gated event, valid_distinct_approvers counted by the verifier's exact rule, k_declared bound via --source only when the re-derived smt_spec_sha256 matches the trace) for an auditor's own rubber-stamping test; presents the distribution and the distinct-KEY count (distinct-PERSON is unprovable), does NOT verify the distribution, prove any decision correct or authorized, score meaningfulness, or gate a verdict -- run nous verify for the cryptographic proof
• Witnessed-Run Evidence -- the second evidence type: a signed realized-run trace with explicit stratified-trust declaration (evidence_kind/cost_binding/provider_token_integrity) and the three-link trust chain
• NDEC Format -- portable proof-carrying decision attestation: a signed dossier wrapped in a DSSE / in-toto v1 envelope, offline-verifiable with verify_ndec.py or nous verify <file>.ndec; carried-verifier pin plus canonical-template allowlist
• Verifier-Digest Registry -- cross-version canonical confirmation: a signed, optionally Rekor-v2-anchored allowlist of official verify_offline.py template digests; on a local canonical miss a logged-tier registry confirmation closes trusting-trust across NOUS versions (evidences publicly-logged allowlist membership, not verifier correctness)
• Stratified Trust Design -- frozen trust vocabulary and serialization contract (the cryptographic interface)
• Codegen Binding -- bind a runtime trace to the specific compiled program via a fourth subject leg codegen_sha256 (sha256 of generate_python output, version-independent); stamped by the run harness, re-derived online by nous conformance verify --source and folded into binding_ok; evidences a trace names the exact compiled program, does NOT prove the run executed (execution attestation out of scope) and is also offline (S156: manifest and certificate carry the signed leg; the portable verifier confirms sha-equality with cryptography + stdlib), though program re-derivation stays online and execution attestation is out of scope
• NOUS VSA -- a SLSA Verification Summary Attestation over an already-signed manifest, trace, and conformance certificate: nous vsa emit writes a DSSE-wrapped in-toto Statement v1 plus a portable zero-trust verify_vsa_offline.py that re-derives the verdict from the eight obligations (rejects a lying verificationResult), recomputes input digests canonically, and re-checks any carried coverage Farkas with pure rational arithmetic; evidences that a verification occurred over named artifacts with a re-derivable verdict, does NOT attest the run executed and adds no new trust root
• SLSA Provenance -- SLSA Provenance v1 over the release wheel and sdist: a DSSE-wrapped in-toto Statement v1 signed by a dedicated builder key (distinct from the VSA verifier key), honestly labeled SLSA Build Level 1 (ad-hoc operator-run release script, not hosted or isolated); evidences build composition via Ed25519 over the DSSE payload with an optional Rekor v2 anchor, does NOT prove builder integrity, hermeticity, isolation, or reproducibility, and adds no PROVES leg and no guard
• Runtime Governance Crosswalk -- maps NOUS primitives to the framework-neutral runtime-governance category (Willis 2026); states where NOUS exceeds the baseline (bounded Z3/Farkas PROVES leg, cryptographic anchoring, supply-chain provenance) and where it deliberately does not operate (monitor, not guard); backed by a machine-readable, OSCAL-aligned coverage profile
• Attestation Receipt -- close trust link 3 for the TEE case: an offline-verifiable provider-signed inference receipt pinned via a NOUS-signed Attestation Pinning Record (APR), making provider_token_integrity=tee_attested emittable and --require-attestation meaningful
• Continuity Ledger -- a tamper-evident sequence of conformance-certified runs sealed under a C2SP tlog-checkpoint head; an RFC 6962 Merkle root over the link digests EVIDENCES head-fixity (Lock 1) and an opt-in Farkas budget envelope PROVES sum(declared caps) <= B (Lock 2); since S180 the budget cert rides a committed in-tree leaf so the root transitively binds the cost-cap proof for a future ML-DSA-44 signature, and an independent timestamped 0x04 witness cosignature (key-isolated) EVIDENCES external observation; since S183 a prior checkpoint plus an RFC 9162 consistency proof EVIDENCES the ledger is append-only between two heads (no rollback, rewrite, or truncation); since S185 the same consistency proof carries a segment in-envelope leg that PROVES (boolean over root-committed conformance-cert fields, no solver) every appended run in the witnessed segment is conformance-certified bound_transfer_ok under the signed root -- adding segment-scoped enforcement over honestly-recorded non-conformant runs -- while NOT proving the declared cost ceiling did not rise across the segment; monitor not guard, offline-verifiable with stdlib + cryptography
• Predetermined-Change Envelope -- one signed artifact, two evidence legs over the same envelope: cumulative MEMBERSHIP (is the composed baseline->current obligation delta inside the declared Annex IV 2(f) envelope; decidable SA/GA/GQ set ops) and temporal PRE-COMMITMENT (was the envelope RFC 3161 + Rekor v2 timestamped before the build it governs; three states anchored-absolute/anchored/post-hoc), the "dated and signed ... with regard to predetermined changes" evidence of Annex IV 2(g); MONITOR not gate (every verdict rc 0, integrity-only fail-closed), EVIDENCES never proves, substantiality deferred to the notified body
• Envelope Ledger -- the append-only, order-fixed commitment sequence over governed-artifact checkpoints; C2SP tlog-witness cosignatures EVIDENCE non-equivocation of the committed history; permanent genesis-leaf origin, 0x01 log signature / 0x04 witness cosignature, offline-verifiable; monitor not guard, evidences never proves
• Witness Provisioning -- the operational companion: persistent XDG log key, the permanent origin, genesis-at-zero, and the public Witness Network join (staging tier; production not yet offered); an operator-run witness is a test harness, not independence
• Santander mech-gov Adapter -- consume-only evidence adapter over a Santander mech-gov DecisionResult; signed decision-structural payload + two digests (upstream/projection) + optional Rekor v2 anchor of the entropy nonce (public logging and log-ordering, NOT trusted time); hashes-not-raw, interop-not-production, evidences never proves, monitor not guard
• Guardrails AI Adapter -- consume-only evidence adapter over a Guardrails AI ValidationOutcome; signed decision-structural payload + two digests (upstream/projection) + optional Rekor v2 anchor of the projected payload (public logging and log-ordering, NOT trusted time); hashes-not-raw, interop-not-production, evidences never proves, monitor not guard
• LLM Guard Adapter -- consume-only evidence adapter over an LLM Guard scan_output; signed decision-structural payload + two digests (upstream/projection) + optional Rekor v2 anchor of the projected payload (public logging and log-ordering, NOT trusted time); hashes-not-raw, interop-not-production, evidences never proves, monitor not guard
• Rejected Ideas -- the Gate's negative output made durable: an append-only ledger of ideas consciously NOT built, each with its recon, rejection reason, and revisit trigger; DO-NOT-BUILD only, distinct from the build-eligible-deferred frontier design docs
• Engineering Constitution -- the model-agnostic engineering process layer above the project instructions: research-first ordering, the Innovation Gate, failure-first analysis, and the honest boundary as method; the HOW to this file's WHAT, model-independent
• Closure Attestation -- a per-(policy, interval) signed completeness commitment over the operator's own declared governed-action set (key-indexed CONIKS/akd sparse Merkle trie, non-membership sound against a malicious operator); a surfaced in-scope action provably absent from the signed root is inconsistent with the operator's own completeness assertion, the cryptographic form of adverse inference; the public witnessed surface commits only {policy_id, interval, root} while action_count stays auditor-only; EVIDENCES a commitment to completeness, never completeness itself, bites only when an omission surfaces through another channel (latent-evidence bound), monitor not guard, PROVES nothing; independent witnessing targets staging and is PENDING the Witness Network join, riding the same envelope-log origin as PCE
• Architecture Decision Records -- the append-only ADR ledger: every shipped architecture decision with its rejected alternatives, tradeoffs, an append-only Evidence Ledger of when it held in production, and a "Still true?" footer; the fourth register beside the handoffs, REJECTED_IDEAS.md, and the frontier design docs

Contributing

NOUS is developed under a non-standard model: single maintainer, chat-driven, idempotent patch scripts, 10-phase release pipeline. External contributions are welcome but follow an "issue first, PR after we agree on shape" intake. See CONTRIBUTING.md and CODE_OF_CONDUCT.md.

Security issues should be reported via GitHub Security Advisories, not public issues.

Stats (v5.73.1)

Metric	Value
Tests	2495 passing, floor 2494 (PYTEST_FLOOR enforced)
Regression	byte-identical harness, 0 baseline drift
Shipped templates	9 (templates/*.nous)
Grammar	Lark LALR, bilingual EN+GR
AST nodes	Pydantic V2 strict models
Lint rule codes	13 (L000 - L012, L100)
CLI subcommands	62 (nous --help)
Pricing schema	v2.0 (currency-agnostic, per-table _currency)
Manifest schema	v1.0 (Ed25519-signed, offline-verifiable, optional Rekor transparency_log)
Verification surfaces	3 (browser endpoint, offline Python, full CLI)
Latest changes	See CHANGELOG.md for per-release detail

Status

NOUS is free and open source under the MIT License. It is built and maintained by one person, a researcher, not a company -- no team, no funding, no reference deployments. It is research and infrastructure, offered as-is. If you want to discuss the work, I am on LinkedIn (https://www.linkedin.com/in/hlias-staurou-a632a197). Security issues via GitHub Security Advisories.

License

MIT. See LICENSE.

The MIT License covers the source code. Trademark rights over "NOUS", "Noosphere AI", "AetherProof", and "Asklepios" are reserved separately; see TRADEMARK.md.

Changelog

See CHANGELOG.md. Latest release: v5.73.1.