Graphenium
Docs GitHub

By Lambda Alpha Labs

The pre-flight architecture gate for AI agents.

Graphenium mechanically blocks code changes that violate module boundaries, bypass service layers, or introduce structural drift—before code is written.

Star on GitHub Run Core locally
  • MIT core local-first pre-flight linter
  • Zero-config modularity and drift protection
  • Agent-native pre-flight linter and CI gate
graphenium gate · pr #1842 live
BLOCK

Agent changed authentication flow

+128 −41 · auth/session

Risk High
diff · session_manager.rs
@@ session refresh path @@
 fn refresh_token(ctx: &Ctx) -> Result {
-  validate_scope(ctx.scope)?;
+  // agent: broadened scope for MCP agents
+  validate_scope(ctx.scope.or_default())?;
   rotate(ctx.session_id)
 }

8 callers · 2 public APIs

blast radius · 14 symbols
auth session api tests ?
  • source-backed paths14
  • public API routes3
  • unresolved edges1
confidence profile
EXTRACTED (AST-Proven)43%
Safe to plan against
INFERRED (Heuristics)57%
Explore; blocked from editing until read
AMBIGUOUS (Collisions)0%
Gated; require manual check
gate decision
Rejected

Pre-flight policy violation with structural hints

  • Abort direct DB dependency from controllers
  • Refactor call path to route through AuthService
  • Run 'gm check --delta --plan plan-xyz' locally
DELTA GATE Zero-drift modularity audit
POLICY Pass · warn · review · block
MIT licensed Open-source Core
Local-first No cloud required
34 MCP tools Agent-native interface
9 languages Polyglot graph extractors
CLI + CI From laptop to pipeline
MIT licensed Open-source Core
Local-first No cloud required
34 MCP tools Agent-native interface
9 languages Polyglot graph extractors
CLI + CI From laptop to pipeline

The enterprise gap

AI agents code fast. Graphenium keeps your architecture intact.

AI coding agents suffer from structural blindness and context decay. Over long chats, they lose track of system instructions (like CLAUDE.md) and optimize for local edits. Graphenium establishes external governance outside the LLM context, turning architecture into an enforced compile-time contract.

  1. Soft guardrails decay

    Natural language instructions (CLAUDE.md) and system prompts are dropped when context windows fill up. Graphenium enforces boundaries outside the LLM context, preventing “vibe coding” from degrading your codebase.

  2. Reviewers fight technical debt

    Instead of evaluating functional logic, senior engineers waste time catching bypassed service layers, unapproved module imports, and code bloat introduced by autonomous assistants.

  3. CI checks only test behavior

    Standard tests and style linters are blind to structural drift. An agent can write spaghetti code that still passes unit tests. Graphenium fails the build on architectural decay.

How it works

Design, gate, verify, and govern with one architecture linter.

Before editing

Declare design pre-flight

The agent registers its proposed classes and imports in a virtual workspace. Graphenium’s Datalog solver checks the design plan before a single line of physical code is written.

During changes

Enforce boundaries mechanically

Graphenium blocks direct boundary violations and transitive layering bypasses in real-time, preventing the agent from violating your module layout.

After edits

Audit post-edit compliance

Graphenium compares the modified code against the approved virtual plan, automatically detecting scope creep and unplanned file edits.

In CI

Gate modularity decay

Zero-drift delta gating calculates the change’s modularity delta (ΔQ) in your build pipeline, failing the build if a PR degrades your codebase structure.

Graphenium Core

The local pre-flight linter and architecture gate.

The MIT-licensed engine compiles your codebase into relational Datalog facts—so agents declare a design plan and get mechanically blocked before writing code that violates your architecture.

View on GitHub Read the docs
quick start 
$ gm init
$ gm run . --no-semantic --no-viz
$ gm doctor --graph graphenium-out/graph.json
$ gm query "authentication flow" --budget 2000
0
cloud required for Core

AST-only path · local graph · MIT

AST-only pre-flight checks with no cloud required

Planning workspaces and zero-drift delta queries offline

Active trust gating: agents are blocked from editing unverified files

Works offline; source leaves your machine only if you opt in

Trust model

Agents should know the difference between proven, inferred, and risky.

Graphenium attaches active gating policies to every relationship so agents cannot edit files they haven’t verified or cross boundaries they haven’t proven safe.

auth session api token tests

Graphenium Gate

PR and CI containment gating.

Gate is the planned commercial control layer. It automates pre-flight policy checks, blocks PR scope creep, runs modularity delta audits, and generates risk-sorted test recommendations in your CI/CD pipeline.

  • Pre-flight policy checks against architecture boundaries
  • Zero-drift modularity delta (ΔQ) audits per PR
  • Block scope creep and unplanned file edits
  • Risk-sorted verification plans reviewers can act on
Graphenium Gate · Pre-flight

BLOCK — Pre-flight policy violation

block
blast radius14 symbols · 3 API routes
modularity deltaΔQ -0.04 (threshold: -0.02)
surprisecross-boundary edge score 6.8
gatepolicy.json violation detected
Pre-flight policy check BLOCK 
Graphenium Gate: BLOCK — Pre-flight policy violation

Changed area
  auth/session_manager.rs
  api/middleware/token_guard.rs

Modularity delta
  ΔQ -0.04 exceeds tolerance (-0.02)
  Cross-boundary surprise score 6.8

Gate
  policy.json violation: controllers→db_conn rejected

Request early access

For platform, DevEx, security, and AI tooling teams evaluating merge governance for agent-generated code.

We only use this to contact you about Gate early access. No spam.

Email us instead

Product family

Local pre-flight linter. CI containment gate. Enterprise control plane.

Start as a local developer tool and grow into organization-wide policy, drift detection, and architectural governance for AI-native software engineering.

Open source

Graphenium Core

The MIT-licensed local pre-flight linter and architecture gate. Run AST-only checks locally, manage planning workspaces, and run zero-drift delta queries offline.

  • Local pre-flight policy checks
  • Datalog-powered planning workspaces
  • Zero-drift modularity delta offline
Open on GitHub →
Commercial

Graphenium Gate

PR and CI containment gating. Automate pre-flight policy checks, block PR scope creep, run relative modularity delta audits, and generate risk-sorted test recommendations in your CI/CD pipeline.

  • GitHub and CI workflow
  • Modularity delta audit per PR
  • Scope-creep detection
Request access →
Enterprise

Graphenium Enterprise

Organization-wide controls for serious AI coding adoption: central policies, audit history, multi-repo graph registry, SSO, RBAC, and self-hosted deployment.

  • Policy and audit console
  • Cross-repo impact analysis
  • Private cloud and self-hosted
Talk to us →

Agent-native interfaces

Works where agents and reviewers already operate.

Use Graphenium locally through the CLI, expose pre-flight architecture gates through MCP, then move the same checks into PRs and CI with Graphenium Gate.

34 MCP tools
9 language families
0 cloud required for Core

For agents

graph_info, safest_path, analyse_symbol, next_files_to_read

For reviewers

blast_radius, diff_graph, verification_plan, review_plan

For governance

agent_change_gate, resolution_report, doctor, check

Direct skill injection

Install scripts copy our linter skill set into Claude Code’s native registry, training the assistant on our pre-flight containment loop out of the box.

Quick start

Build your first graph in minutes.

Start local and AST-only. No API key is required for the core graph.

Open GitHub repo Read docs
terminal 
$ gm init

$ gm run . --no-semantic --no-viz

$ gm doctor --graph graphenium-out/graph.json

$ gm query "authentication flow" --budget 2000

$ gm serve --graph graphenium-out/graph.json

The operating principle

AI agents code fast. Graphenium keeps your architecture intact.

Graphenium gives AI coding workflows the pre-flight architecture gates they need—enforcing boundaries, preventing drift, and failing the build on structural decay before code reaches production.

Start with Core Request Gate access

Questions about pilots, partnerships, or enterprise use? hello@graphenium.dev

FAQ

Built for serious AI coding adoption.

Is Graphenium another code search tool?

No. Search tools help humans locate files. Graphenium is an active, pre-flight linter and architecture gate that compiles your codebase into relational Datalog facts to mechanically block structural drift before code is written.

What is Graphenium Gate?

Graphenium Gate is our commercial PR and CI/CD governance layer. It analyzes incoming code modifications, runs modularity delta audits, blocks scope creep, and ensures every agent-generated PR complies with your architectural boundaries.

Does Graphenium send source code to a cloud service?

Graphenium Core runs locally by default. The AST-only path does not require an API key. Source code is only sent outside your environment if you explicitly configure a semantic provider or hosted service.

Which languages are supported?

Graphenium documents support for Rust, Python, Go, JavaScript, TypeScript, Java, C, C++, and C#. Language depth varies by extractor and resolver maturity.

Who should use it?

Developers can use Core locally. Platform teams, DevEx teams, security leaders, and AI tooling teams should evaluate Gate when they want policy and evidence around agent-generated code changes.

Pilot & contact

Talk to us about Graphenium.

For design partners, enterprise pilots, partnerships, or general questions, reach out directly.

hello@graphenium.dev

Design partners, enterprise pilots, partnerships, and general questions.

security@graphenium.dev

Security and vulnerability reports