aglang

🤖

Packaged Agent Skill

Install the aglang Codex skill so agents know when to read AGENTS.md, run aglc checks, and treat architecture verdicts as coding feedback.

🔁

Work-in-progress Validation

Agents can run check-file during focused edits and check --all before finishing, long before a pre-commit hook fires.

🧩

Enterprise Graph Policies

Model transitive reachability, data classification propagation, trust boundaries, DI closure, and lifetime hazards as enforceable architecture rules.

🏗️

Architecture as Code

Write human-readable .ag files with explicit enforcement levels for formal Z3 rules, deterministic policies, and advisory guidance.

🔒

Solver-backed Commit Enforcement

Pre-commit hooks and CI checks run deterministic constraint solving against real extracted code behavior. Violations are rejected with precise diagnostics.

📚

Docs Freshness Policies

Use change_policy rules to require docs, skills, package metadata, and implementation surfaces to move together in the same checked diff.

🌐

8 Language Extractors

Automatically extract routes, dependencies, and infrastructure from C#, Python, TypeScript, Go, Rust, Java/Kotlin, Swift, and more.

🔌

Pluggable & Extensible

Add custom extractors via the plugin protocol. Import from OpenAPI or Terraform.

Install

Install the CLI and the packaged agent skill:

bash

npm install -g @collivity/aglang
aglc install-agent-skill

Then bootstrap a project:

bash

aglc add /path/to/your/project

aglc add creates the starter architecture spec, compiled artifact, git hook, and project-specific agent manifest. Full getting-started guide →

How agents should use aglang

The packaged skill gives agents generic aglang behavior; the project repo supplies its own rules through AGENTS.md, skill.json, and architecture.o.

Read AGENTS.md before coding.

Validate focused edits with aglc check-file --arch architecture.o --file <path> --json.

Validate the whole guarded project before finishing with aglc check --arch architecture.o --project . --all --json.

Ask before creating, editing, regenerating, or compiling .ag architecture specs or generated architecture artifacts.

Use planning/design sessions for architecture authoring, where engineers can review intended spec changes.

How it works — at a glance

aglang is a dual-compiler system exposed as an agent workflow. Your .ag spec compiles to SMT-LIB math formulas; during coding or commit checks, a second compiler extracts what changed code actually does and feeds it to the solver:

Your .ag spec                 Your codebase (file or project)
      │                                    │
      ▼                                    ▼
[aglc compile]              [AST extractors — 8 languages]
      │                                    │
      ▼                                    ▼
 architecture.o              FlowFact[]  (what code talks to what)
(SMT constraints)                         │
      │                                   │
      └────────────── solver-backed check ────────┘
                             │
                    SAT → pass ✓  │  UNSAT → reject with proof ✗

Agents use the same interface while code is still in progress; pre-commit hooks and CI use it as the final enforcement point. The solver is deterministic math — no LLM guesses. Full pipeline walkthrough →

aglangArchitecture Guardrails for Coding Agents