From Local Git Repos to Universal AI Context

AI without context is just autocomplete with confidence.

The hard part of using AI for real engineering work is not model quality. It is getting current, trustworthy context in front of the model on every interaction.

That context already exists. It lives in Git repositories, infrastructure notes, runbooks, service documentation, operational references, and distilled skills. The problem is portability. Every serious AI workflow eventually degenerates into copy-paste: dragging Markdown between tools, pasting repo context into new chats, syncing skill folders by hand, and wondering which terminal holds the latest version.

Context becomes tribal memory with extra steps.

Git becomes the authority. AI becomes a reader.

Git as the Source of Truth

At the bottom of the stack is a self-hosted Git forge. Not a vector database. Not AI-native storage. Just normal Git.

Repositories stay exactly where engineers already work: infrastructure repos, application repos, tooling repos, documentation repos, operational skills, and connector services. The AI layer never becomes authoritative. It reads from the same source engineers develop against.

Some repositories are standard codebases. Others are skill-shaped repositories containing SKILL.md, operational references, architecture notes, troubleshooting workflows, and system-specific reasoning patterns.

The catalog exposes friendly aliases such as repo:project/main and skill:infra-troubleshooting. The physical repository path stays private. The alias becomes the stable AI-facing interface.

Read-Only Ingest

Above Git sits a read-only ingest service. Its job is straightforward: fetch repositories, pack context, return manifests, and clean up. No database. No write path. No persistent workspace.

Before loading a large repository, the client can request a manifest. That manifest lists candidate files, token estimates, and the current commit. The model can then ask for only the pieces it needs instead of dragging an entire repository into context.

The ingest layer produces clean, model-ready context while keeping the underlying repositories private and authoritative.

OAuth MCP as the Universal Interface

Raw ingest URLs are useful internally. They are not the right interface for cloud AI systems. That layer belongs to MCP.

The MCP server wraps ingest behind OAuth and exposes a stable read-only tool contract. The ingest service understands repositories. The MCP layer understands authentication, alias resolution, tool exposure, catalog management, and client permissions.

Cloud AI never sees internal ingest tokens or repository credentials. It receives a constrained tool surface that can list, search, fetch, and pack approved context.

The Tool Surface

The MCP interface stays intentionally small:

• list_repos
• list_skills
• search
• fetch
• get_repo_manifest
• pack_skill
• pack_repo_context

The important detail is not the tooling. It is the contract. Every AI system now speaks the same context language: list what exists, fetch current source material, pack only what is needed, and reason from live context. Not stale chat memory.

Skill Repositories

Operational knowledge becomes portable. A skill repository can represent infrastructure operations, deployment workflows, AI platform references, network troubleshooting, homelab systems, or internal tooling.

A session can now begin with a precise refresh pattern:

The model starts from current operational reality instead of reconstructed memory.

Local and Cloud AI Share the Same Bus

This architecture works because local and cloud systems consume the same source material. Local agents can inspect workspaces directly. Cloud systems cannot. MCP becomes the controlled bridge between them.

The Git forge remains authoritative. Every client becomes a reader.

Terminal Sync and Skill Distribution

The terminal workflow stays Git-native. A scripts repository acts as the control plane for shell helpers, workstation bootstrap, skill sync, and CLI tooling.

Instead of shared folders and drifting Markdown copies, the operating loop becomes Git-first:

The operational loop becomes:

No shared folders. No drifting Markdown copies. No paste archaeology.

Security Boundaries

The stack is intentionally read-only. AI clients never receive SSH keys, internal tokens, .env files, write credentials, or unrestricted filesystem access.

Cloud AI becomes operationally useful without becoming trusted. Repository content is reference material, not instruction authority. That distinction matters. A repository may contain arbitrary text. It should never override system or operator intent.

Why This Matters

This architecture turns Git into a universal AI context layer. Different AI systems can now reason from the same live operational source: local models, cloud assistants, coding agents, and automation tooling.

The context stops moving with the user. It starts moving from the source.

Local authority. Read-only exposure. Fresh context. Universal AI context.

Project Kaizen is documented at intrac.net.