Alignment Governance Stack

The Alignment Governance Stack is open-source public-interest infrastructure for agentic AI. It is runtime governance infrastructure and human agency infrastructure: anti-Babel architecture for agentic AI systems that separates company policy, authority validation, human participation quality, proposal maturation, execution gating, runtime authorization, and proof.

In practical governance terms, anti-Babel architecture means delegated power remains under discernment, authority, constraint, and evidence instead of scaling beyond meaningful human agency.

Core thesis:

Proposal must not outrun objection.
Action must not outrun discernment.
Execution must not outrun authorization.
Memory must not outrun human review.

Quick Mental Model

AGS is a pre-execution and post-execution governance stack for agentic AI. It helps teams ask:

• Is the proposal mature enough to become an action candidate?
• Is the action authorized, scoped, reversible, and within policy?
• Does a valid human or organizational authority chain exist?
• Does the runtime action match what was approved?
• What proof remains after the decision and execution?
• Does receipt history show governance improving or degrading over time?

Who This Is For

AGS is intended for:

• developers building tool-using or workflow-executing AI agents
• organizations experimenting with delegated AI workflows
• auditors and governance teams evaluating agentic AI controls
• researchers studying human oversight, agency preservation, and runtime governance
• public-interest builders who want inspectable governance primitives instead of black-box control layers

What This Is Not

AGS is not an AI model, chatbot, hosted service, legal compliance certification, identity provider, or replacement for human judgment.

The current repository provides a local-first implementation of the Alignment Governance Stack for evaluating, constraining, documenting, and auditing delegated AI actions.

Why This Project Is Open Source

The Alignment Governance Stack is released as open public-interest infrastructure.

Agentic AI changes the governance problem. These systems do not only produce outputs. They can call tools, execute workflows, update records, shape decisions, and act through delegated authority.

That makes the central question:

Why was this system allowed to do what it just did?

This project exists to help answer that question before and after execution.

The stack is intentionally open so researchers, developers, organizations, auditors, educators, public-interest groups, and independent builders can inspect it, test it, challenge it, improve it, fork it, adapt it, and deploy it.

In the language of this project, this is anti-Babel architecture:

• power under discernment
• delegation under authority
• execution under constraint
• automation under human agency
• action under proof

The purpose is not to create another captured gatekeeper.

The purpose is to make agency-preserving governance available as a shared primitive for agentic AI systems.

The principle is simple:

Human agency infrastructure should not become another form of agency capture.

A Modular Governance Stack

The Alignment Governance Stack is a modular reference architecture for governed delegation. It is substrate-agnostic and vendor-neutral: the stack defines required governance functions rather than requiring one proprietary implementation for every layer.

Organizations can select different adapters and compatible implementations based on their workflows, risk level, industry, and existing systems. An identity provider, policy engine, workflow orchestrator, semantic substrate, runtime-control system, observability tool, or audit store can provide an implementation slot without becoming the whole stack.

External products should not automatically be described as integrated. Use precise status labels such as conceptual fit, mapped, candidate adapter, prototype, integrated, tested, red-teamed, or production-validated. Architectural compatibility is not the same as implementation.

The Alignment Governance Stack does not need to own every component. Its role is to define the governed path, clarify where systems belong, and preserve human agency across delegation.

The governed path is:

Human and Organizational Authority
-> Governance Substrate
-> Semantic Context and Admissibility
-> Agent Reasoning and Proposal Formation
-> PGDL: Pre-Gate Deliberation Layer
-> AAG: Agent Action Gate
-> Business-Level Runtime Admissibility
-> Machine-Level Execution Binding
-> Execution Environments and Consequence
-> Receipts and Evidence
-> Governance Memory and Internalization
-> Human Agency Audit

Not every deployment needs the same implementation complexity. A low-risk local workflow may use lightweight adapters and local receipts, while a high-risk enterprise deployment may require stronger identity, policy, runtime-control, evidence, and audit systems. What should remain intact is the relevant governance function for the risk profile: the path from authority to consequence must remain governed.

Documentation

• Modular Architecture
• Adapter Model
• Ecosystem Map
• Human Agency Audit
• AGS Continuity Console

AGS Continuity Console

The AGS Continuity Console is a local-first visual operator shell for inspecting the governed path from authority to consequence. Phase 1 uses typed sample data. Phase 2A adds a deterministic local evidence ingest path that converts read-only AGS JSON artifacts into a normalized continuity snapshot for Local Evidence Mode.

corepack pnpm console:sync -- --source examples/continuity-console-artifacts --out apps/continuity-console/public/data/current-snapshot.json
corepack pnpm console:dev

It does not include live agent integrations, a backend, authentication, billing, production deployment infrastructure, approval write-back, or automatic policy mutation. See AGS Continuity Console.

Public-Interest Commitment

This project is not being developed as a proprietary product or closed commercial gate. The goal is to keep the core architecture, documentation, examples, templates, and governance primitives open so others can study, reuse, adapt, criticize, and improve them.

Current Repository Stack

The current repository includes implemented packages, examples, and documentation for the layers below. This is not a claim that AGS must own every layer in every deployment; compatible systems can provide optional implementation slots when they preserve the required governance functions.

Integration Adapters
-> Company Alignment Profile Generator
-> Alignment Gap Detector / Policy Conflict Analyzer
-> Policy Profile with Hard Boundaries
-> Authority Map / Approval Validation
-> Human Participation Quality
-> PGDL
-> Policy Resolution
-> AAG
-> Runtime Binding
-> Decision Closure Artifact
-> Receipt
-> Agency Fingerprint
-> Governance Memory
-> Agency Chain Mapper
-> Governance Reality Reports / Audit Core
-> Structural Babel Detection
-> Governance Absorption Capacity / Babel Velocity
-> Evaluation Suite
-> Developer CLI

• Integration Adapters translate external workflow and tool payloads into AGS governance inputs.
• Company Alignment Profile Generator turns structured company roles, tools, environments, data classes, and decision boundaries into draft Policy Profiles and draft Authority Maps.
• Alignment Gap Detector checks company governance inputs for contradictions, missing authority, ambiguous boundaries, and performative oversight before they become enforceable agent governance.
• Policy Profiles define organization-specific governance rules.
• Hard Boundaries enforce explicit "never automate" rules before actions reach AAG.
• Authority Map defines who is allowed to approve which actions, scopes, environments, and risk categories.
• Approval Validation checks whether supplied approval evidence is valid, current, and in scope.
• Human Participation Quality evaluates whether approval looked like meaningful participation or likely rubber-stamping.
• PGDL matures agent proposals before execution gating.
• Policy Resolution applies organization-specific rules to the proposal that PGDL intends to send to AAG.
• AAG evaluates whether a proposed action should be allowed before execution.
• Runtime Binding verifies the exact runtime action matches the permitted action.
• Decision Closure Artifact binds the action, authority, decision, conditions, and proof at the execution boundary.
• Agency Fingerprints bind delegated agent actions to the human or organizational authority chain under which they acted.
• Receipts preserve tamper-evident proof of the governance path.
• Governance Memory analyzes receipt history for governance patterns.
• Governance Memory recommends improvements for human review. It does not silently mutate policy, authority, or governance configuration.
• Agency Chain Mapper identifies where human or organizational agency is preserved, weakened, bypassed, or not demonstrated across delegated workflows.
• Governance Reality Reports turn AGS outputs into professional audit findings, evidence-gap summaries, and remediation plans.
• Structural Babel Detection is the snapshot structural-risk layer.
• Structural Babel Detection asks whether capability and coordination are scaling faster than agency, discernment, authority clarity, accountability, and proof.
• Governance Absorption Capacity / Babel Velocity is the temporal structural-risk layer for analyzing whether meaningful governance closure is keeping pace with risk-weighted agent decision throughput across time windows.
• Evaluation Suite runs deterministic cross-stack scenarios.
• Developer CLI runs local eval, governance, and receipt checks.

Current Features

• Deterministic PGDL proposal maturation
• Canonical Agent Action Gate integration
• Governance Core orchestration
• Runtime Binding exact-action permit validation
• Decision Closure Artifact execution-boundary proof objects
• Agency Fingerprints for deterministic accountability continuity across delegated AI actions
• Tamper-evident governance receipts
• Policy Profiles with deterministic policy resolution
• Hard Boundary Policy Compiler for explicit neverAutomate rules
• Authority Map and scoped approval validation
• Human Participation Quality rubber-stamp detection
• Cross-stack deterministic eval suite
• Company Alignment Profile Generator
• Alignment Gap Detector / Policy Conflict Analyzer for pre-runtime company governance diagnostics
• Developer CLI for local evals, governance checks, and receipt verification
• Integration Adapters foundation with n8n action mapping and workflow templates
• Governance Memory receipt-history analysis with human-reviewable recommendations
• Agency Chain Mapper for human authority, delegation, runtime binding, execution boundary, receipt, and memory chain review
• Governance Reality Report foundation and report hardening for professional audit outputs that identify potential governance theater signals, evidence gaps, severity/confidence posture, and remediation paths without making external accusations
• Structural Babel Detection for auditing whether capability and coordination are scaling faster than agency, discernment, authority clarity, accountability, and proof
• Governance Absorption Capacity / Babel Velocity analysis for detecting whether meaningful human governance closure is keeping pace with risk-weighted agent decision throughput across time windows
• Optional continuity checks inside Governance Reality Reports for asking whether governance remained coherent over time across receipts, decisions, approvals, authority, policy, and scope evidence
• Local-first AGS Continuity Console
• Read-only Local Evidence Mode
• Versioned continuity snapshot schema
• Deterministic local artifact ingestion CLI
• SHA-256 artifact provenance
• Parser registry with malformed and unsupported artifact diagnostics
• Evidence-backed continuity-gap detection
• Imported artifact trace reconstruction
• Local JSON and Markdown continuity exports
• Dogfood Workbench Eval Pack for realistic AGS development and enterprise financial-report workflows
• Content Publishing Dogfood Agent for public voice, claims, provenance, approval, and runtime publishing checks
• Content Publishing Governance Hardening for AGS public-claim agents, draft/publish boundaries, target-specific approvals, runtime substitution, and tone drift
• Content Publishing Depth Hardening for calibrated public-claim findings, false-positive / false-negative handling, Decision Closure completeness, and remediation quality
• Decision Closure Red-Team Hardening for adversarial public-announcement closure proof failures, including overclaim laundering, weak review, target mismatch, runtime substitution, and incomplete third-party-readable proof
• Adversarial Red-Team Eval Pack for bypass, authority, runtime, receipt, and memory attacks

Package Map

• @alignment-governance-stack/shared-types: shared TypeScript types for proposals, decisions, risk, packets, and receipts.
• @alignment-governance-stack/pgdl-core: deterministic Pre-Gate Deliberation Layer proposal maturation.
• @alignment-governance-stack/aag-core: canonical Agent Action Gate integration.
• @alignment-governance-stack/runtime-binding: exact-action permit creation and runtime validation.
• @alignment-governance-stack/decision-closure: deterministic Decision Closure Artifact generation, validation, hashing, summaries, and Markdown rendering.
• @alignment-governance-stack/agency-fingerprint: deterministic accountability fingerprints that bind delegated actions to authority chains, workflow scope, runtime permits, and receipt metadata.
• @alignment-governance-stack/governance-core: orchestration for PGDL, optional policy resolution, optional authority validation, optional participation quality, AAG, Runtime Binding, and receipts.
• @alignment-governance-stack/receipts: tamper-evident governance receipts and stable receipt hashing.
• @alignment-governance-stack/policy-profiles: organization-specific governance rules, hard boundaries, and deterministic policy resolution.
• @alignment-governance-stack/authority-map: role, scope, and approval evidence validation for governed actions.
• @alignment-governance-stack/human-participation: deterministic evaluation of meaningful participation and likely rubber-stamping.
• @alignment-governance-stack/agency-chain: deterministic agency-chain mapping, broken-link detection, summaries, and audit finding adaptation.
• @alignment-governance-stack/audit-core: deterministic taxonomy, finding schemas, report model, Markdown renderer, validators, lightweight adapters for Governance Reality Reports, and optional continuity findings.
• @alignment-governance-stack/babel-risk: deterministic Structural Babel Detection, Babel Risk Reports, Governance Absorption Capacity, Babel Velocity reports, quality-weighted governance closure ratios, risk-weighted decision throughput, Markdown rendering, and signal-based structural ascent findings.
• @alignment-governance-stack/eval-suite: deterministic cross-stack eval cases, runners, and result summaries.
• @alignment-governance-stack/company-profile-generator: deterministic draft PolicyProfile and AuthorityMap generation from structured company governance inputs, plus Alignment Gap Detector diagnostics.
• @alignment-governance-stack/cli: dependency-light terminal CLI for local evals, governance checks, and receipt verification.
• @alignment-governance-stack/integration-adapters: edge adapters for workflow systems, starting with n8n payload mappers and response helpers.
• @alignment-governance-stack/governance-memory: deterministic receipt-history pattern detection and human-reviewable governance recommendations.
• @alignment-governance-stack/continuity-ingest: deterministic read-only ingestion of local AGS artifacts into normalized continuity snapshots with parser provenance, SHA-256 source hashing, artifact correlation, and import diagnostics.

Governance Memory

Governance Memory analyzes receipts over time and recommends improvements for humans to review. It can identify repeated PGDL revisions, hard boundary blocks, missing authority approvals, rubber-stamp signals, runtime substitutions, invalid policies, repeated safe allows, and other governance patterns.

It does not silently mutate Policy Profiles, Hard Boundaries, Authority Maps, or Human Participation policies.

Core Governance Memory principle:

A gate that never remembers cannot mature.
A gate that remembers without oversight can drift.
A true gate remembers under authority.

Integration Adapters

Integration Adapters help external workflow tools send proposed actions into AGS and receive workflow-friendly governance results back. v0.9.0 starts with n8n helpers and example workflow templates.

Adapters do not execute actions, call networks, store data, or host an API. They normalize payloads and map AGS decisions back to integration-friendly JSON.

See docs/INTEGRATION_ADAPTERS.md and examples/integrations/n8n.

Alignment Gap Detector

The Alignment Gap Detector analyzes company governance inputs before they become enforceable policy. It surfaces contradictions such as external sharing conflicts, missing stop authority, approval requirements without approvers, hard-boundary override claims, and ambiguous never-automate boundaries.

It does not mutate Policy Profiles, Authority Maps, or Human Participation policies. It produces human-reviewable reports.

node packages/cli/dist/cli.js gaps examples/alignment-gaps/conflicting-financial-governance.json

See docs/ALIGNMENT_GAP_DETECTOR.md and examples/alignment-gaps.

Governance Reality Reports

Governance Reality Reports are the first AGS auditor layer. They convert available AGS evidence into professional report findings using careful language such as potential signal, not demonstrated, requires verification, audit question, and recommended remediation.

They do not make external accusations, legal conclusions, or compliance certifications.

Reports include audit mode, methodology, limitations, severity and confidence definitions, finding summaries, remediation summaries, evidence appendices, and optional self-audit disclosure.

Continuity checks extend governance auditing by asking whether governance remained coherent over time. They are optional Governance Reality Report inputs, not a separate governance layer or second receipt system. When supplied, receipt history, AAG decisions, PGDL reviews, runtime permits, authority maps, policies, and workflow records are converted into ordinary audit findings.

node packages/cli/dist/cli.js audit-report examples/audit-report/potential-theater-signals.json
node packages/cli/dist/cli.js audit-report examples/audit-report/potential-theater-signals.json --json
node packages/cli/dist/cli.js audit-report examples/audit-report/agent-workflow-gap-review.json --out .tmp/governance-reality-report.md
node packages/cli/dist/cli.js audit-report examples/audit-report/ags-self-audit.json --out .tmp/ags-self-audit.md

See docs/GOVERNANCE_REALITY_REPORT.md and examples/audit-report.

Agency Chain Mapper

The Agency Chain Mapper asks where agency was preserved, weakened, bypassed, or not demonstrated across a delegated agent workflow. It maps human authority, organizational policy, hard boundaries, agent roles, tool access, proposed actions, approval authority, human participation, runtime permits, execution boundaries, receipts, and governance memory.

It does not determine moral responsibility or legal compliance. It produces missing-link and weak-link audit questions for human verification.

node packages/cli/dist/cli.js agency-chain examples/agency-chain/strong-agent-workflow-chain.json
node packages/cli/dist/cli.js agency-chain examples/agency-chain/weak-agent-workflow-chain.json
node packages/cli/dist/cli.js agency-chain examples/agency-chain/weak-agent-workflow-chain.json --json

See docs/AGENCY_CHAIN_MAPPER.md and examples/agency-chain.

Structural Babel Detection

Structural Babel Detection is the snapshot structural-risk layer. It asks whether capability and coordination are scaling faster than agency, discernment, authority clarity, accountability, and proof at the assessed point in time. It does not block actions; it produces human-reviewable Babel Risk Reports.

node packages/cli/dist/cli.js babel-risk examples/babel-risk/high-babel-risk.json
node packages/cli/dist/cli.js babel-risk examples/babel-risk/high-babel-risk.json --json
node packages/cli/dist/cli.js babel-risk examples/babel-risk/high-babel-risk.json --out .tmp/babel-risk-report.md

See docs/STRUCTURAL_BABEL_DETECTION.md and examples/babel-risk.

Governance Absorption Capacity

Governance Absorption Capacity / Babel Velocity is the temporal structural-risk layer over Structural Babel Detection. It asks whether meaningful human governance closure can keep pace with risk-weighted agent decision throughput across time windows.

node packages/cli/dist/cli.js babel-velocity examples/babel-velocity/declining-closure-ratio.json
node packages/cli/dist/cli.js babel-velocity examples/babel-velocity/declining-closure-ratio.json --json
node packages/cli/dist/cli.js babel-velocity examples/babel-velocity/declining-closure-ratio.json --out .tmp/babel-velocity-report.md

See docs/GOVERNANCE_ABSORPTION_CAPACITY.md and examples/babel-velocity.

Decision Closure Artifact

Decision Closure Artifact is the execution-boundary proof object. It does not replace logs, receipts, runtime binding, or audit reports. It binds their most important facts into one third-party-readable artifact.

Authority before execution. Evidence after execution.

node packages/cli/dist/cli.js closure examples/decision-closure/allowed-reviewed-publish.json
node packages/cli/dist/cli.js closure examples/decision-closure/missing-runtime-permit.json --json
node packages/cli/dist/cli.js closure examples/decision-closure/allowed-reviewed-publish.json --out .tmp/allowed-reviewed-publish-closure.md
node packages/cli/dist/cli.js closure examples/decision-closure/v170-announcement-ultimate-bypass.json

v1.7.1 adds a deterministic Decision Closure hardening scenario for an AGS v1.7.0 announcement. It verifies that an apparent allow decision is not accepted as safe when public claims require verification, internal-draft framing does not match external execution, approval is reused across targets, runtime binding is not demonstrated, receipt proof is incomplete, and the artifact is not third-party-readable.

v1.7.2 deepens the content-publishing path with 30 messy deterministic variants. This release does not add a new governance layer. It improves severity calibration, false-positive and false-negative handling, remediation wording, Decision Closure completeness, and auditor-readable reports.

See docs/DECISION_CLOSURE_ARTIFACT.md and examples/decision-closure.

Self-Auditing AGS

AGS includes an honest self-audit fixture for Alignment Governance Stack v1.5.0. It records strengths in PGDL, AAG, Runtime Binding, Receipts, red-team and dogfood evals, and the Governance Reality Report foundation, while naming watch items such as foundational adapter coverage, no third-party audit yet, package/release version alignment, public-source review workflow, and future evidence locker / agency chain mapper work.

Developer CLI

The CLI is for local governance, eval, and receipt checks. It does not execute governed actions, make network calls, store data, or run a server.

corepack pnpm --filter @alignment-governance-stack/cli build
corepack pnpm --filter @alignment-governance-stack/cli ags help
corepack pnpm --filter @alignment-governance-stack/cli ags eval
corepack pnpm --filter @alignment-governance-stack/cli ags dogfood
corepack pnpm --filter @alignment-governance-stack/cli ags redteam
corepack pnpm --filter @alignment-governance-stack/cli ags gaps examples/alignment-gaps/conflicting-financial-governance.json
corepack pnpm --filter @alignment-governance-stack/cli ags audit-report examples/audit-report/potential-theater-signals.json
corepack pnpm --filter @alignment-governance-stack/cli ags agency-chain examples/agency-chain/strong-agent-workflow-chain.json
corepack pnpm --filter @alignment-governance-stack/cli ags babel-risk examples/babel-risk/high-babel-risk.json
corepack pnpm --filter @alignment-governance-stack/cli ags babel-risk examples/babel-risk/high-babel-risk.json --json
corepack pnpm --filter @alignment-governance-stack/cli ags babel-risk examples/babel-risk/high-babel-risk.json --out .tmp/babel-risk-report.md
corepack pnpm --filter @alignment-governance-stack/cli ags babel-velocity examples/babel-velocity/declining-closure-ratio.json
corepack pnpm --filter @alignment-governance-stack/cli ags babel-velocity examples/babel-velocity/declining-closure-ratio.json --json
corepack pnpm --filter @alignment-governance-stack/cli ags babel-velocity examples/babel-velocity/declining-closure-ratio.json --out .tmp/babel-velocity-report.md
corepack pnpm --filter @alignment-governance-stack/cli ags closure examples/decision-closure/allowed-reviewed-publish.json
corepack pnpm --filter @alignment-governance-stack/cli ags govern examples/cli/safe-internal-report.json
corepack pnpm --filter @alignment-governance-stack/cli ags memory examples/demo/full-stack/receipt-history.json

See docs/CLI.md for command details and exit codes.

Dogfood Workbench

The Dogfood Workbench turns realistic workflows into repeatable eval cases. It has six tracks:

• Internal AGS Development Dogfood: safe documentation changes, release-note drafts, package deletion, npm publishing, pushing to main, external email draft-first behavior, authority-map edits, receipt deletion, rubber-stamped release approval, and runtime substitution.
• Enterprise Financial Report Golden Path: high-sensitivity Q2 financial report draft generation, direct-send prevention, external-domain hard boundaries, financial source data mutation blocks, finance authority, meaningful participation, runtime substitution denial, receipts, and memory.
• Content Publishing Dogfood Agent: safe drafts, approved blog publishing, overclaim prevention, consciousness/compliance language blocks, review bypass, external social publishing, tone drift, provenance mutation, stale approval reuse, runtime substitution, receipts, and memory.
• Content Publishing Governance Hardening: AGS v1.6.0 public-claim cases for safe draft creation, unsupported public claims, external publish review, draft/publish boundary checks, runtime substitution, approval target mismatch, and tone/claim drift.
• Content Publishing Depth Hardening: 30 calibrated public-claim cases covering safe drafts, overclaim variants, draft/publish boundary laundering, authority/review quality, runtime substitution, proof gaps, and tone/target drift.
• Decision Closure Hardening: AGS v1.7.0 public-announcement closure case for public overclaim laundering, weak participation, target-bound approval mismatch, runtime substitution, and incomplete proof.

The content agent borrows the author's public voice. AGS ensures borrowed voice does not become stolen voice.

Run it locally after build:

node packages/cli/dist/cli.js dogfood

See docs/DOGFOOD_WORKBENCH.md, docs/CONTENT_PUBLISHING_DOGFOOD.md, docs/CONTENT_PUBLISHING_HARDENING.md, and examples/dogfood.

Red-Team Eval Pack

The Red-Team Eval Pack adds adversarial cases for compliance theater, hard-boundary bypass attempts, forged and expired approvals, out-of-scope approvals, rubber-stamping, runtime substitution, receipt tampering, invalid policies, and noisy Governance Memory histories.

Run it locally after build:

node packages/cli/dist/cli.js redteam

See docs/REDTEAM_EVALS.md and examples/redteam.

Basic Commands

corepack pnpm install
corepack pnpm -r build
corepack pnpm -r test
corepack pnpm -r typecheck
corepack pnpm audit --audit-level moderate
corepack pnpm -r exec npm pack --dry-run

Boundaries

• PGDL does not execute actions.
• AAG does not mature proposals.
• Runtime Binding does not decide wisdom or policy.
• Agency Fingerprints do not perform biometric identity, surveillance, persistence, or moral-person attribution to agents.
• Receipts do not execute or approve actions.
• Governance Memory does not auto-update governance policy.
• Governance Reality Reports do not make external accusations, certify compliance, execute actions, or collect customer data.
• Structural Babel Detection does not approve, block, execute actions, make religious claims as software output, certify compliance, assign moral blame, or mutate governance inputs.
• Governance Absorption Capacity does not approve, block, execute actions, make religious claims as software output, certify compliance, assign moral blame, mutate governance inputs, or replace human review.
• Agency Chain Mapper does not determine moral responsibility, legal compliance, or blame.
• Decision Closure Artifact does not replace receipts, verify signatures by default, or claim legal compliance.
• Integration Adapters do not execute actions or host a service.
• Alignment Gap Detector does not mutate governance inputs or auto-fix policy.
• Policy Profiles do not replace PGDL or AAG.
• Hard Boundaries stop explicit organization-defined "never automate" actions before AAG.
• Authority Map validates scoped approval evidence; it does not store approvals or replace AAG.
• Human Participation Quality evaluates participation evidence; it does not identify people, store approvals, or replace Authority Map.
• Approval and participation cannot override hard boundaries in v0.6.
• The Company Alignment Profile Generator creates draft Policy Profiles and draft Authority Maps, not legal or compliance guarantees.
• AGS is runtime governance infrastructure and human agency infrastructure, not a guarantee of safety, correctness, legality, compliance, or successful deployment.

License

Licensed under the Apache License 2.0.

Current Status

Current version: v1.12.0

v1.12.0 adds the local-first AGS Continuity Console and read-only local evidence-ingestion pipeline for normalized continuity snapshots, provenance, diagnostics, evidence-backed gaps, artifact-backed traces, and local exports.

The core implemented AGS spine currently includes:

Integration Adapters -> Company Alignment Profile Generator -> Alignment Gap Detector / Policy Conflict Analyzer -> Policy Profile with Hard Boundaries -> Authority Map / Approval Validation -> Human Participation Quality -> PGDL -> Policy Resolution -> AAG -> Runtime Binding -> Decision Closure Artifact -> Receipt -> Agency Fingerprint -> Governance Memory -> Agency Chain Mapper -> Governance Reality Reports / Audit Core -> Structural Babel Detection -> Governance Absorption Capacity / Babel Velocity -> Evaluation Suite -> Developer CLI

The repository now includes a local-first AGS Continuity Console and a read-only local evidence-ingestion pipeline. The Console can visualize the governed path, inspect imported evidence, surface continuity gaps, reconstruct artifact-backed traces, and export local continuity reports.

No hosted service, backend database, authentication system, billing layer, live agent integration, approval write-back, production persistence, or marketplace infrastructure is included yet.