Grid Protocol
Open Framework · Git-Native · Any AI Client

Your AI is not a tool.
It's your architectural partner.

Grid gives AI models persistent, procedural memory that lives in your repository, travels with your code, and compounds across every session — so the model shows up as a peer, not a blank slate.

Get started on GitHub See how it works
# Day 1 — fresh project
→ Initialize the Grid from G667 at GitHub
✓ Session state initialised
✓ Ready. The model knows your project.

# Day 13 — same project, new session
→ Continue where we left off
Loaded: architecture, rest-layer, business-layer
3 pending issues · last decision: JWT session design
✓ No re-explaining. No re-discovering. Just work.
1
setup file — no additional configuration required
0
external services required
∞
AI clients supported
The problem

Treat the AI as a partner.
Give it memory to match.

The model is capable of being a genuine architectural partner — reasoning, proposing, pushing back. But every session starts from zero. You re-explain architecture. You re-state conventions. You re-discover what was already decided. The capability is there. The continuity isn't.

🧠

Context evaporates

Compaction, new sessions, different clients — your project context disappears. The model has no memory of what it helped you build.

🔁

Constant re-explaining

Conventions, architectural decisions, domain vocabulary — you re-teach these every time. Time you could spend building.

📉

Degrades with scale

The larger the project, the more context it needs. Most AI tools get worse as your codebase grows. The model can't keep up.

🔒

Vendor lock-in

Memory features tied to Cursor, Claude Projects, or ChatGPT don't travel across tools. Switch clients and you start over.

Who this is for

Not every project.
The right ones.

Grid is infrastructure, not a shortcut. It earns its keep on projects where consistency matters, decisions accumulate, and the work spans more than a few sessions.

✓

Long-running projects

Anything spanning weeks or months of AI-assisted development. The investment in skills compounds — each session starts sharper than the last.

✓

Architecturally serious work

Multiple layers, cross-cutting concerns, security requirements, non-obvious dependencies. The more there is to know, the more the skill system earns its keep.

✓

Small teams, high AI involvement

Where the model is a genuine co-developer, not an autocomplete tool. Grid assumes the model is a first-class participant — not a prompt recipient.

✓

Developers who maintain discipline

Skills that lag behind code are worse than no skills — they mislead. The Grid asks for one thing: keep skills current with the work. If that's your practice, the Grid compounds it.

How Grid works

Procedural memory
that lives in your repo

Grid is not retrieval. It's not RAG. It's event-driven procedural knowledge — loaded at the right moment, owned by your team, versioned like code.

1

Skills — not prompts, not docs

SKILL.md files define what the model should do and when — not just facts to retrieve. They live close to the code they describe. A REST layer skill lives next to the REST code. A commit convention skill loads before every commit.

2

Auto-discovery — no manual index

The skill scanner walks your repository for every .grid/ directory, registers all skills into the session state cache, and keeps it fresh as you add new modules.

3

Skills load on demand — not all at once

Context is precious. Grid's trigger system routes skill loading to the right phase — architecture skill when entering a module, commit skill before committing, issue management when the user mentions tasks. Never flooding the window with irrelevant knowledge.

4

A dependency mesh — not just skills, but their relationships

Skills declare their relationships in frontmatter metadata. The skill scanner builds a live dependency graph across your codebase. When you load an area skill, Grid automatically surfaces what it depends on. When a change touches a module, Grid knows which other areas to check. Architectural impact is visible before you write a line.

5

One place owns all session state

Skills, active tasks, workflow steps, triggers — all managed centrally via grid-state.py. File-based JSON, gitignored, client-agnostic. Works on GitHub Copilot CLI, Claude Code, Cursor, Windsurf — any AI client that can run a shell command.

6

A guardian enforces discipline

No commit without approval. No task closed without confirmation. No installation without explicit consent. The workflow guardian can't skip gates under time pressure or convenience.

7

Isos — your project's own knowledge

Isos are where the Grid's value accumulates. The programs are infrastructure. Isos are the architectural memory of your project — decisions made, conventions established, domain knowledge discovered — co-authored with the model as the work unfolds. They live close to the code they describe. They never come from a registry. They belong to your project, and they grow in depth and precision with every session.

The Grid programs

A cast of specialists,
not one monolith

Each program owns one concern. Composable, replaceable, independently loadable.

Session Conductor

Runs the session rhythm — workflow steps, trigger timing, compaction recovery. Present at every decision point, visible only when something needs attention.

Session State Manager

The central memory. Owns skill cache, triggers, tasks, and workflow state. Every program delegates persistence here — nothing survives a session without it.

Skill Scanner

Walks the repository and registers every SKILL.md it finds. Builds the dependency mesh from frontmatter declarations. Detects naming conflicts before they cause behavioral drift. Keeps the knowledge map current without manual upkeep.

Workflow Guardian

Enforces approval gates at every decision point. No commit, close, or install without passing through. The last line of defence for collaboration integrity.

Task Coordinator

Manages the session task list and tracks open work across sessions. Coordinates the full lifecycle of issues from discovery to close.

External Connector

Bridges the Grid to external tools — git, GitHub, and beyond. Routes each action to the right driver skill, keeping integrations modular and independently replaceable.

Program Manager

Installs, updates, and removes programs from the Grid registry. Add new capabilities to the collaboration layer without touching the core.

Issue Tracker side project

Local, model-friendly, browser-viewable issue management with no external service required. Born in the first real Grid project — offered freely to anyone who finds it useful.

Project Skills yours

The primary value surface of the Grid. Isos are the accumulated architectural memory of your project — co-authored with the model as decisions are made, patterns emerge, and the codebase grows. They live in the repository, evolve with the work, and deepen every session.

Dependency mesh

Skills know about each other

Each iso declares its relationships in frontmatter. The skill scanner builds a live graph across your entire codebase. Load one area — the mesh tells you what to surface next. Touch a module — the mesh tells you what else to verify. Architectural impact is visible before you write a line.

Real-world result

13 days.
Previously impossible.

"I would never have been able to build this alone in 13 days. I can't even imagine reaching this state with a team in a month or two. The speed was real — but the deeper truth is that this work was previously outside what a solo developer could reach at all. Grid didn't make me faster. It moved the boundary of what was possible."

— Built with an early version of Grid, before the framework was formalised. Solo developer.

13 days · solo Full platform: API, business layer, persistence, REST, auth, security hardening, infra
161 issues Created and tracked across the entire project — architecture, features, bugs, security decisions.
108 closed Documented, confirmed, and merged. Every decision recorded alongside the code that implements it.
One click ships Installer, Docker image, SBOM, log management, and coverage reports — production artifacts on every build.
0 re-explains Every convention, decision, and domain rule persisted across every session via skill files
Day 13 > Day 1 Each session started sharper than the last. Context compounds instead of evaporating.
0 CVE & OSS findings Automated vulnerability and dependency scanning. Clean across the full stack.
CRA ready EU Cyber Resilience Act requirements addressed by design — without a security team or dedicated audit phase.

Every security decision — JWT design, session handling, CSRF protection, input validation, permission modelling, TLS hardening — was discussed exhaustively with the model across multiple issues and sessions. Not security added after the fact. Security reasoned into the architecture from the start. The result reached a secure-by-design level that addresses the requirements of the EU Cyber Resilience Act — without a security team, without a dedicated audit phase.

How Grid is different

Not retrieval. Not prompts.
Collaborative infrastructure.

Most AI memory systems retrieve facts. Grid loads behavior — what to do, when, and why. It's not a smarter tool. It's a different kind of collaboration entirely.

Approach Git-native Client-agnostic Procedural Team-owned No infra
Grid ✓ ✓ ✓ ✓ ✓
IDE-specific rule files ✓ ✗ ✗ ✓ ✓
Vendor memory / project context ✗ ✗ ~ ✗ ✓
RAG / embedding stores ~ ~ ✗ ~ ✗
External memory services ✗ ~ ✗ ✗ ✗
Get started

One instruction.
Your project, remembered.

Open your project in any AI client. Say:

"Initialize the Grid from G667 at GitHub"

The model fetches and installs — no cloning, no scripts, no manual steps.

View on GitHub Read the bootstrap