Glyphmap AI EnforcementCut token waste.
Keep agents in scope.

default loading

GlyphMap for autonomous coding

Decision-tree guardrails. Local-first enforcement.

From $29/mo per developer.

Cut token waste.

Verified 86% reduction. A full 5-hour Claude session, only 4% of the weekly limit used.

86%Average token reduction per developer task with GlyphMap enforcement active.

Before

240k

After

34k

No bulk repo dumps. No surprise spend. Just the slice that matters.

Keep agents in scope.

Every action answered by a decision tree. Deterministic, in plain English.

Allow

Inside intent, scope verified

Ask

Ambiguous, confirm with developer

Deny

Out of scope or restricted path

No policy code to write. No surprise edits to merge.

Get the highlights.

Plain-English decisions.

Allow, deny, ask, warn, restore — answered through decision trees, not hand-written policy.

Allow

Inside intent, scope verified

Ask

Ambiguous, confirm with developer

Deny

Out of scope or restricted path

Verified context.

The local service maintains files, symbols, imports, packages, and confidence levels.

84kSymbols, imports, and chunks indexed per repo, kept fresh on save.

Drift stays out.

Tasks store objective, phase, allowed paths, touched files, and recent receipts.

0Files touched outside the active task scope, by design.

Local source of truth.

Compact audit records and summaries, batched to the server when it makes sense.

Receiptauth.flow

Allow

src/auth/login.ts

Ask

schema migration

Deny

vendor/legacy

Offline-safe enforcement.

Deterministic decisions run on the developer’s machine without a network round trip per hook.

On-device

Zero network calls per hook

Value packed

Say hello to a good buy.

GlyphMap turns developer intent into local enforcement. The developer answers three guided questions, and the local runtime turns the answers into allow, deny, ask, warn, restore, context, and receipt decisions.

Pays for itself on the first session.

Verified context lives outside the model window. The agent stops re-reading the repo every prompt.

$387

Estimated monthly token spend reclaimed per developer.

Tokens per day300k

30k300k20M

Glyphmap is an enforcement engine not an AI Agent

GlyphMap is the enforcement engine above the agents.

Claude Code, Codex, and Grok Build bring the intelligence. GlyphMap brings the verified project map, the active task scope, and the deterministic decisions that keep every change inside the developer's intent.

It does not generate code. It does not edit files. It does not play the agent. It evaluates what the agent wants to do and answers: allow, deny, ask, warn, restore, context, or receipt.

Claude Code

OpenAI Codex

Grok Build

VS Code

Enforcement engine

GlyphMap

allow

ask

deny

-if (token) return user

+if (session) return user

+session.touch()

No code generation.

GlyphMap never proposes a diff, never edits a file, and never plays the role of the agent. It evaluates what the agent wants to do against the verified project map and the active task.

CLAUDE.md

AGENTS.md

No prompt engineering required.

Decision trees live in versioned configuration. CLAUDE.md and AGENTS.md stay as developer notes — they are not the enforcement surface.

On-device

No source code in the cloud.

The local service stores tokenized facts only — files, symbols, references, diagnostics — never raw source. Receipts and summaries batch to the server.

What you get

Six things that change on day one.

Decision-tree guardrails, verified context, archived deletes, readable receipts, smaller context packets, and an adapter-agnostic boundary.

files out of scope

Scoped task mutation.

Active tasks narrow project allowed paths. Writes outside the task scope are denied with an in-scope hint instead of an after-the-fact diff review.

Decisions log: deny → out_of_scope_path

Verified context, not inference.

The service-maintained project map knows which files, imports, packages, and symbols are real — so the agent stops inventing them.

Service map: 12,418 facts · 0 unresolved imports

src/auth/legacy.ts

_removed/auth/legacy.ts

Archive over delete.

Any rm, unlink, or find -delete redirects to project-root _removed. Nothing is hard-deleted while a session is running.

Receipt: restore → moved to _removed/

Receipt

Receipt batch

Receipts you can read.

Every allow, deny, ask, warn, or restore produces a receipt with rule, path, and reason. Post-session reconciliation becomes read-only audit.

Receipt batch: 412 entries · synced

Smaller context packets.

Durable project understanding lives outside the model context window. The AI receives focused packets and clearer corrections instead of repeated discovery.

Context budget: bounded across compaction

Adapter-agnostic boundary.

Claude Code, OpenAI Codex, Grok Build, VS Code, and the terminal all defer to the same local runtime. The enforcement boundary is identical across agents.

Three agents. One project map.

Performance and battery life

Less context. Less spend.

Blasts and lasts.

GlyphMap keeps durable project understanding outside the model context window. The AI receives smaller context packets and clearer corrections instead of repeated discovery.

Bounded context. Hours of headroom.

A multi-hour autonomous session lives inside a context budget that does not balloon across compaction. Long sessions stay productive instead of timing out into a reset.

5 hrsVerified autonomous session length on a single Claude session limit before reset.

Unenforced

full

GlyphMap

28%

Up to 70%

Smaller context packets

Verified

Up to 4x

Fewer corrective retries

Verified

Unlimited

Local decisions per project

Verified

Compare

Worth the upgrade?

You’ll love it.

CapabilityWithout GlyphMapWith GlyphMap

Project context

Re-read on every prompt

Maintained by the local service

Guardrail rules

Hand-written prose policies

Decision trees + receipts

Task drift

Caught after the diff

Caught before the write

Audit trail

Scattered logs

Local receipts + batched sync

Deletes

Hard rm

Archived to _removed

Hallucination guard

Catch invented things.

Real files. Real symbols. Real imports.

GlyphMap reduces hallucination by grounding AI actions in the service-maintained project model. When the AI invents a file, import, package, or symbol, GlyphMap can catch it and send a clear message back.

Invented imports get caught before they ship.

The local scanner resolves every import against the project map. Real files, real packages, real symbols, every time.

import auth from src/auth/login

import db from src/db/client

import auth from src/auth/legacy

suggested: src/auth/login

src

auth

vendor

Path checks

Block writes outside project or task allowed paths.

import db from src/db

import x from src/missing

suggest: src/db/client

Import resolution

Reject references the scanner cannot resolve.

invented symbols shipped

Symbol checks

Warn or block on invented symbols and packages.

vendor/legacy.ts

_removed/vendor/legacy.ts

Archive over delete

Deletes redirect to project-root _removed.

.env, secrets, vendor

Restricted reads

Honor remote restricted read paths exactly.

Family

All in the family.

All the must-haves. All in GlyphMap.

GlyphMap reaches every place AI coding lives: editor, terminal, agent, and CI.

Claude Code, governed.

Thin adapter that defers to the local runtime for every mutation.

OpenAI Codex, same rules.

Same deterministic decisions and receipts across the stack.

Grok Build, in scope.

xAI sessions resolve to the same map, decisions, and receipts as every other agent.

VS Code, inline.

Inline prompts mirror the local runtime decision.

$glyphmap scan

scanning 412 files...

map fresh

Terminal

Shell commands resolved to affected paths before scope checks.

build #7421

passed

CI summaries

Master context is built from approved scans, branches, or CI runs.

Web dashboard

Accounts, projects, policy templates, and batched receipts.

Grok Build

xAI tokens, on a leash.

Same map. Same decisions. Same receipts. In xAI dollars.

Grok Build runs hot. Parallel subagents, a 256K context window, and cached input pricing turn every prompt into a budgeting decision. GlyphMap pins durable project understanding outside the window, denies out-of-scope writes before the agent retries, and shifts repeated tokens into the cached tier.

The cached tier does the heavy lifting.

Cached input lands at $0.20 per million versus $1.00 per million for raw input. GlyphMap shapes the system prompt, project-map handoff, and AGENTS.md so xAI cache hits land on every session.

5xCheaper repeated contextxAI pricing, May 2026

Input$1.00 / 1M

Cached input$0.20 / 1M

Output$2.00 / 1M

Context window256K

Cached tier first.

Decision-tree templates and the project map handoff are stable across sessions. Repeated lookups settle at $0.20 per million instead of $1.00, and the runtime never restuffs the codebase into the prompt.

5x cheaper repeated context

Eight subagents. One scope.

Up to eight Grok Build subagents can run in parallel, each consuming its own context budget. GlyphMap narrows the active task scope before each spawn, so every subagent inherits allowed paths, not the whole repo.

8 subagents, 1 scope

Retries, denied.

Hooks reject after the agent tries, and every rejection is a retry that burns more tokens. GlyphMap evaluates intent before the model commits, so out-of-scope writes never reach the retry loop.

Pre-action decisions

Sample session math

A long session, recomputed.

A long Grok Build session that would normally consume roughly 5M input and 2M output tokens. Cached context, focused packets, and denied retries shift the bill.

Unenforced session$9.00

With GlyphMap$5.00

Estimated savings~44%

With GlyphMap, broken out

Raw input1.5M at $1.00 = $1.50

Cached input3.5M at $0.20 = $0.70

Output1.4M at $2.00 = $2.80

Directional estimate. Actual ratio depends on codebase size, subagent fan-out, and retry frequency.

Drift goes nowhere.

Eight parallel subagents can compound drift across compaction. GlyphMap blocks invented imports, denies protected-path writes, and archives deletes to _removed before any subagent multiplies the error.

Side by side

With GlyphMap, the boundary is local.

Probabilistic systems need deterministic boundaries. Decision trees evaluate against the verified project map and the active task, not against prompt cooperation.

DimensionWithout GlyphMapWith GlyphMap

Project context

Re-read on every prompt; degrades after compaction

Maintained by the local service; survives compaction

Guardrail rules

Hand-written prose policy in CLAUDE.md / AGENTS.md

Decision-tree configuration with versioned templates

Task scope

Implicit; drift caught after the diff

Active task allowed paths; drift caught before the write

Protected artifacts

Trusted to a prompt instruction

Allow / deny / ask via the local runtime, every call

Deletes

Hard rm; recovery is git-history-only

Archived to project-root _removed automatically

Audit trail

Scattered transcript logs

Local receipts + batched sync with rule and reason

Multi-agent consistency

Claude, Codex, and Grok Build each follow separate prompt-encoded rules

One decision-tree config; all adapters honor it

Keep exploring GlyphMap.

Developers

Build agents that respect the map.

See the runtime contract, adapter pattern, and decision-tree schema.

Open

$29

/ dev / month

Pricing

Plans for solo, pro, and teams.

Choose a plan that matches how many projects, workstations, and developers you support.

Open

Sync strategy

Local-first by design.

Local decisions should not require a hosted service call on every hook, file event, or save. Sync is intentional: policies, summaries, receipts, and dashboards.

412

entries in last batch

Durable receipts

Compact audit records and task summaries — never raw source code.

auth.ts+12 refsuseSession+4 diagssha:a82cchunk:18

Tokenized facts

Files, symbols, references, and diagnostics — stored as facts, not code.

Batched sync

Dedupe by sourceHash and tokenHash, with expiresAt for per-file deltas.

GlyphMap values

What we believe.

Privacy

No raw source code in hosted storage. Local enforcement, batched sync.

Off

Control

No daemon until login succeeds and the project is selected.

Receipt

Allow

src/auth/login.ts

Deny

vendor/legacy

Clarity

Receipts say allow, deny, ask, warn, or restore — with reasons.