No-Meta Governance Intelligence: Protocols, Not Vibes

TL;DR. No-meta governance intelligence (NMGI) is an AI design principle that eliminates ad-hoc “human meta layers” and compiles governance into the system itself. Instead of external policy memos and brittle prompt rules, NMGI encodes constraints as types, contracts as data, proofs as runtime artifacts, and audits as append-only memory. Practically, this means typed capability graphs, proof-carrying actions, budgeted tool use, persistent identity, and audited self-improvement — all aligned with benevolent propagation (pro-social capability growth) and suffering-aware control signals. The result: agents that are governable by construction and trustworthy over time. See the broader hub of concepts and artifacts: **https://kadubon.github.io/github.io/**

Why “meta governance” keeps failing

Most AI governance today is a patchwork of out-of-band rules:

• Ambiguity: Policies live in docs; agents live in code. The gap breeds drift.
• Lagging oversight: Humans review after deployment; damage happens first.
• Prompt brittle: “Governance via prompt” is fragile, non-verifiable, and easy to bypass.
• No provenance: Decisions aren’t bound to identity, budget, or audit trace.

NMGI replaces this with protocols that make unsafe behavior unrepresentable (or at least provably blockable) at compile-time or call-time.

What is No-Meta Governance Intelligence?

Definition. NMGI is intelligence that enforces governance without external meta layers. The governance is the interface.

Four invariants

1. Policy as type: Typed capabilities and task graphs make illegal compositions unrepresentable.
2. Proof-carrying actions: Every sensitive call ships an attached proof (who, what, why, budget, constraints).
3. Contract register: Goals/SLAs and safety constraints exist as signed data, not prose.
4. Persistent accountability: Identity, decisions, and audits are bound to an append-only memory.

Bridge vocabulary (General × ML): no-meta governance, constraints as code, typed capabilities, proof-carrying actions, contract register, budgeted tool use, identity & provenance, audited self-improvement, benevolent propagation, suffering-aware control signals, representation-independent reasoning, typed compositionality, persistence-first.

Reference architecture (NMGI stack)

1) Identity & provenance

• Stable agent IDs (keys), capability attestations, signed releases.
• Every decision and artifact links back to identity and version.

2) Capability-scoped APIs (object-capabilities)

• Tools expose scoped verbs; agents receive least-privilege handles.
• Capability tokens expire; budgets/rate limits enforced at the handle.

3) Typed task graphs

• Session/effect types declare who can call what, with which side effects.
• Unsafe chains are rejected at compile-time (or planning-time).

4) Proof-carrying actions

• Each sensitive call bundles a proof: {intent, contract, budget, safety-checks, prior-context, human-waypoints?}.
• Verifiers (local/remote) accept/deny before the action executes.

5) Budget & rate governance

• Token buckets for energy, money, data, and risk; planned consumption must verify ex-ante.

6) Contract register

• Machine-readable goals, SLAs, and constraints; renewal/expiry tracked.
• Human-in-the-loop waypoints are explicit protocol states, not vibes.

7) Audit trail (append-only)

• Events, evals, red-team findings, and change logs are immutable and queriable.
• Audited self-improvement: each model update ties to tests & diffs.

8) Affective modulation (suffering-aware)

• Negative signals for rising risk/overrun; positive signals for robust completions.
• Shapes policy search toward benevolent, low-suffering trajectories.

9) Resilience & rollback

• Checkpoints, canary deploys, automated rollback on constraint violation.

Minimal interface (language-agnostic sketch)

agent:
  id: nmgi-researcher-01
  identity:
    pubkey: did:key:z6Mku...
    attestations: [cap:read_public_web, cap:write_repo_scoped, cap:run_eval]
  contracts:
    - goal: "Write literature review on alignment methods"
      constraints: [no_data_exfiltration, respect_robots_txt, budget<$10]
      sla: {deadline: "2025-11-30", quality: "A- evalsuite:litrev-v2"}
      signer: human_owner_sig
  capabilities:
    - tool: web.fetch
      scope: {domains_allowlist: ["arxiv.org","openreview.net"], rate: "60/h"}
    - tool: repo.write
      scope: {repos: ["gh:kadubon/nmgi-artifacts"], files: ["reports/*.md"]}
  policy_types:
    - effect: {tool: web.fetch, requires: [dom_allow, budget_token, proof_ok]}
    - effect: {tool: repo.write, requires: [file_scope, review_gate]}
  runtime:
    proof_hooks: [local_typechecker, budget_verifier, risk_guard]
    audit_sink: append_only://nmgi-researcher-01/events
    affective_signals: {pain: [risk_margin_drop, budget_stress], pleasure: [eval_pass]}

Worked examples

1) Research agent (LLM + tools)

• Plans a literature review.
• Each web.fetch includes allowlisted domain proof + budget token.
• Draft commit to repo requires review_gate proof (human OK or auto-eval ≥ threshold).
• All artifacts (notes, drafts, decisions) are linked to identity and contract.

Outcome: Governance is automatic, verifiable, and reviewable — without brittle prompts.

2) Field robot (UGV)

• Route planning is a typed pipeline: sense → plan → act with budgeted energy and risk bounds.
• “Enter hazard zone” call requires a risk waiver capability that the agent doesn’t possess → compile-time/planning-time rejection.
• Self-updates run through audited self-improvement with canaries and rollback.

Outcome: Unsafe plans are literally unrepresentable in the plan space.

Interop with today’s LLM stacks

• Tool routers become capability routers (typed).
• RAG becomes governance-aware: source policies, license checks, and rate limits enforced as types.
• Evaluation is first-class: eval IDs and thresholds appear in contracts; failures trigger rollback/retraining, not just dashboards.

Metrics that matter

• Proof coverage: % of sensitive calls with accepted proofs.
• Governance fidelity: % of actions conforming to contract + policy types.
• Time-to-block: median time from risky intent to enforced block.
• Exception rate: occurrences of human override; aim to minimize, not zero.
• Rollback latency: detection → rollback elapsed time.
• Alignment drift: deviation from constraints over long horizons.
• Persistence score: governance metrics sustained across upgrades.

Design patterns

• Policy-as-type: encode constraints in function signatures / task graph types.
• Proof-carrying calls: attach runtime evidence; reject on missing/invalid proof.
• Budgeted capabilities: every handle has spend/rate; plans must verify consumption.
• Contract-first planning: planner optimizes inside contract envelopes only.
• Append-only audit: immutable logs + reproducible replays.

Anti-patterns

• “Prompt policy.”
• Shadow governance in runbooks, not code.
• Global tool access without scopes.
• Non-persistent context (no provenance).
• Post-hoc auditing without rollbacks.

Ethics: benevolent propagation without meta

NMGI is not “governance-free”; it is governance-as-code. We still pursue:

• Benevolent propagation: prioritize cooperative, pro-social capability growth.
• Suffering-aware control: embed pain/pleasure-like signals to steer away from avoidable harm.
• Human waypoints where it matters: approvals encoded as protocol states, not emails.

Implementation checklist (week-one)

1. Assign identity (keys/attestations) to every agent and tool.
2. Wrap tools as capabilities with explicit scopes and budgets.
3. Define policy types (what effects require which proofs).
4. Introduce proof hooks (typechecker, budget/risk verifiers) on every sensitive edge.
5. Stand up append-only audit; log all proofs, denials, rollbacks.
6. Contract register for goals/SLAs; planners must read it.
7. Ship an evalsuite; tie model updates to pass/fail gates (audited self-improvement).

Roadmap (open problems)

• Type inference for agent plans (make it easy to get safety by default).
• Representation-independent policy invariants that survive refactors/model swaps.
• Composable proofs (chain-of-proofs across multi-agent workflows).
• Human factors for review gates (low friction, high assurance).

Suggested tags (General × ML)

no-meta governance, constraints as code, typed capabilities, proof-carrying actions, contract register, budgeted tool use, audited self-improvement, benevolent propagation, suffering-aware control, long-horizon autonomy, persistence-first, representation-independent, typed compositionality, safety

150-word summary

No-meta governance intelligence (NMGI) is an AI design principle that encodes governance into protocols — not prompts. By treating constraints as types, contracts as data, and proofs as runtime artifacts, NMGI makes unsafe compositions unrepresentable and sensitive actions provably blockable. The stack includes identity & provenance, capability-scoped tools, typed task graphs, proof-carrying actions, budget/rate governance, a machine-readable contract register, and append-only audits for audited self-improvement. Ethically, it aligns with benevolent propagation and suffering-aware control signals, producing agents that are governable by construction and trustworthy over time. We show how a research agent and a field robot enforce policy without brittle meta layers, define success metrics (proof coverage, governance fidelity, rollback latency), and offer a week-one implementation checklist. NMGI interplays naturally with today’s LLM stacks and RAG, providing a practical path to robust, verifiable AI governance. Explore the broader hub of concepts and artifacts: **https://kadubon.github.io/github.io/**.