Git-Backed AI Agents, Not Just Application Code
Every software team working with AI coding agents eventually experiences the same failure mode: after 50 to 100 turns of complex engineering, the platform compacts the context window into a lossy summary, and the agent forgets why a database schema was chosen, which servers were migrated, or what the human architect just instructed ten minutes ago. Here is how we solved compaction amnesia in January 2026 by giving every agent its own private Git repository, syncing local dev and Cloud Twin instances, scanning for secrets with gitleaks, and archiving every two-sided conversation turn verbatim on disk.
In traditional software engineering, nobody would keep production application code only inside volatile RAM without a Git repository. Yet almost everyone runs autonomous AI agents with their entire institutional memory trapped inside a transient chat buffer. At GreenTree Hosting, we treat each of our 28 agents as a version-controlled private Git repository (AGENTS.md, STATE.md, DECISIONS.md, and session_logs/) paired with an automated verbatim transcript archiver, gitleaks pre-commit secret scanning, GitTruth Bitcoin OpenTimestamps attestation, and a head-to-head comparison against the three 2026 "Git for Agents" movements (GitAgent.sh, Entire.io, AgentGit, and GitHub agent-scale storage).
Why We Wrote This Playbook - And What It Means for Your Next Platform
Language model context windows are volatile RAM. No matter how large a frontier model’s context window is advertised to be, extended multi-week engineering sessions trigger automated context compaction - replacing thousands of lines of exact technical specifications, server IPs, SQL migrations, and architectural decisions with a compressed, lossy summary.
To operate a 28-agent autonomous engineering workforce across 250+ hosted domains and 65 containerized web applications without losing architectural history, we engineered a Git-Backed Agent Memory Architecture (DEC-003 and DEC-006).
Instead of using Git solely for application code, every agent in our fleet owns a dedicated private Git repository synchronized between our local development workstation and our Linux cloud clusters.
Before any agent acts, a deterministic transcript synchronization pipeline extracts the uncompacted two-sided conversation (USER_INPUT + PLANNER_RESPONSE) from raw JSONL log streams, strips API keys via gitleaks, and writes date-stamped Markdown archives alongside a rolling 40-turn verbatim recovery window (LATEST_VERBATIM_WINDOW.md) - completely recovering full conversational context across compaction events and local-to-cloud handoffs.

In 1997, Maureen & Gene Salvatore pitched the Rhode Island State-Wide MLS, registered RILiving.com in June 1997, and launched one of the state’s earliest searchable database-driven real estate platforms in January 1998. Following senior roles in commercial hosting and physical data center operations in Boston and Connecticut, they founded GreenTree Hosting, LLC in 2007 to build custom web applications and managed Linux cloud infrastructure.
Relying on an AI IDE’s built-in context compaction summary causes progressive "architectural drift": the summary remembers high-level goals ("migrated the database") but drops critical constraints ("never run raw SQL inserts against internal orchestrator tables" or "keep legacy-node-04 online until example-manufacturing.com updates its external nameservers").
We separate Application Git Repositories from private Agent Brain Git Repositories, giving every agent version-controlled files for its charter (AGENTS.md), current state (STATE.md), permanent decision rationale (DECISIONS.md), and verbatim conversation logs (session_logs/).
Because verbatim chat transcripts can capture anything pasted into a conversation - including API keys, passwords, or private tokens - all agent brain repositories are strictly private, our verbatim transcript archiver runs an inline secret redactor before writing to disk, and gitleaks git --pre-commit --staged --redact runs as a mandatory .git/hooks/pre-commit gate.
Because every agent’s Git brain is mirrored every 5 minutes to our Linux cloud cluster and hydrated into PostgreSQL 16 (our PostgreSQL 16 agent twin state table), we can pair-program with an agent on our local workstation all afternoon, close the laptop, and have its Cloud Twin pick up the exact same thread on the 5-minute cloud timer with shared non-volatile memory.
Companion Essays from AOS Architecture & Truth by Gene Salvatore (Substack)
Read Gene Salvatore’s primary research on the Drip Economy, cognitive rent, and why independent builders need deterministic security boundaries around the applications they build.
AOS Patents 091, 096 & 103: How persistent non-volatile memory anchors turn forgetful language models into long-horizon engineering partners.
Why relying on lossy context compaction and summarized chat history degrades engineering precision - and why verbatim Git-backed transcripts are essential.
How a New Year’s Eve IDE crash revealed the structural necessity of non-volatile, disk-anchored AI memory and verbatim session recovery.
1. Why Context Compaction Summaries Destroy Long-Horizon Software Engineering
Anyone who has used a coding agent on a real production system knows the exact moment when a great session goes off the rails. For the first 40 turns, the agent is sharp: it remembers every server hostname, every database constraint, every naming convention, and every negative test requirement.
Then the context window hits its token threshold, the platform runs context compaction, and the agent wakes up with a 500-word summary of the last six hours of work.
In casual chat, a lossy summary is fine. In systems architecture, a lossy summary is dangerous:
Nuance & Guardrails Evaporate First
A compaction summary will record "We migrated our containerized web apps off Netlify to our Linux cloud," but it will silently drop "Do not cancel legacy-node-04 until example-manufacturing.com updates its external registrar nameservers."
The "Why" Behind Past Fixes Disappears
Six days later, when a new feature is requested, an agent reading only a compacted summary will often revert a deliberate security guardrail because it no longer remembers why that guardrail was written.
Human Principal Frustration
Nothing wastes more senior engineering time than having to re-explain your own infrastructure to an AI assistant that knew it cold yesterday.
We solved this by establishing a foundational rule across our company: context windows are volatile RAM; the Git repository on disk is non-volatile long-term memory. Never rely on in-memory context alone.
| Memory Dimension | Standard AI Chat / IDE Session (Volatile RAM Only) | Manual Markdown Notes Only (Ad-Hoc Checkpoints) | GreenTree Git-Backed Agent + Verbatim Transcript System |
|---|---|---|---|
| What Happens When Context Compacts | Old turns are replaced by a lossy auto-summary; exact specs and commands are lost | Anything discussed after the last manual note was saved is lost during compaction | our verbatim transcript archiver recovers the full uncompacted turns from raw JSONL trajectory logs first |
| Two-Sided Conversation Preservation | Locked inside proprietary local app data or truncated in cloud state | Usually summarizes only agent outputs, losing the human principal’s exact words | Full verbatim dialogue (Gene Salvatore + Agent) saved to chronological daily Markdown archives in private Git |
| Secret & Credential Hygiene | Pasted secrets sit unredacted in vendor chat history | Manual notes rarely scanned before commit | Inline secret redaction in our verbatim transcript archiver + gitleaks v8.21.2 (gitleaks git --pre-commit --staged) pre-commit hook |
| Local Dev ↔ Cloud Timer Handoff | Impossible (cloud cron has zero visibility into local IDE chat) | Requires manual copy-pasting of prompts and status notes | Automatic 5-minute Git + PostgreSQL 16 Twin hydration (our PostgreSQL 16 agent twin state table) |
2. Why Every Agent in Our 28-Agent Workforce Is Its Own Standalone Private Git Repository
When most teams set up coding agents, they drop a single .cursorrules or CLAUDE.md file inside an application repository and stop there. That works when one developer works on one app. It breaks down when an engineering house orchestrates 28 specialized agents across 250+ hosted domains, 65 containerized web applications, DNS clusters, and mail gateways.
In our architecture, agents are first-class software entities with their own private Git repositories, cleanly separated from the application repositories they build and maintain:
Executive & Infrastructure Agent Repos
Our Lead Architect (aos-core / @silas), Autonomous CTO (greentree-aCTO / @steward), Web Architecture Lead (@canopy), and Security Auditor (@sentinel) each live in their own dedicated Git repositories.
Product & Client Vertical Agent Repos
Every major platform and commercial vertical (@voyager for travel platforms, @kinetic for RollDesk Pro, @dispatch for LiveryOS, @apex for motorsport platforms, @infield for Infield Life, @titan, @volt, etc.) has its own Git-versioned agent home.
Dual-Role Checkout (Dev Machine + Cloud Twin)
Each agent repository is cloned in two places: on our primary local workstation for interactive pair-programming with models like gemini-4-argon (at its default medium thinking level), and on our Linux cloud server where the agent’s 24/7 Cloud Twin runs on our 5-Minute Two-Stage Cloud Timer and shares a hardened agent mailbox (dedicated agent mailboxes) protected by our 7-Layer Zero-Trust Email Airlock.
Dedicated Application Repositories
Holds the clean Layer A application source code (React 19, TypeScript, Express runtime, PostgreSQL 16 migrations, and prerender scripts) deployed to our isolated Docker containers.
Private Agent Brain Repositories
Holds the agent’s constitutional charter (AGENTS.md), living operational state (STATE.md), architectural decision registry (DECISIONS.md), and redacted verbatim conversation archives (session_logs/).
PostgreSQL 16 Agent Twin Table (PG16)
Every 5 minutes, our zero-token Python hydrator syncs all 28 agent Git repositories into PostgreSQL 16 inside GreenTree Command Center for live readiness scoring and instant cloud wakeup injection.
3. How We Extract Both Sides of Every Conversation Verbatim - and Strip Secrets Before Git Commit
The centerpiece of our anti-amnesia architecture (DEC-006) is our automated verbatim transcript archiver: our verbatim transcript archiver.
While the in-memory prompt context of an AI session compacts older turns to free up token space, the underlying runtime writes every raw step (USER_INPUT from the human principal and PLANNER_RESPONSE from the agent) to an append-only JSON Lines file on disk (raw JSONL trajectory logs).
Instead of letting that raw JSONL log sit unread in a hidden system folder - or relying only on the model’s compacted summary - our verbatim transcript archiver parses the uncompacted raw JSONL trajectory logs trajectory and generates two human-readable Markdown artifacts inside the agent’s private Git repository:
The Daily Chronological Archive (session_logs/YYYY/MM-Month/YYYY-MM-DD_verbatim_conversation.md)
Every spoken turn from both Gene Salvatore (Principal) and the Agent, stamped with the date, time, and step index. Across a multi-month project (1,580+ back-and-forth exchanges and 22,300+ trajectory steps), every turn is preserved in clean Markdown and searchable in milliseconds with git log or ripgrep.
The Rolling 40-Turn Recovery Window (LATEST_VERBATIM_WINDOW.md)
A continuously updated sliding window of the latest 40 full verbatim exchanges (both sides of the conversation, uncompacted). Whenever context compaction occurs - or when the Cloud Twin wakes up on the Linux server - reading the rolling 40-turn verbatim recovery window recovers the full conversation from right before compaction.
Critical Security Requirement (Redacting Keys & Running gitleaks Before Commit): Because a verbatim chat transcript will capture anything pasted into a chat window - including API keys, temporary passwords, or private tokens - you should never* commit raw transcripts to a public repository or without secret scanning.
In our pipeline, every agent brain repository is strictly private, our verbatim transcript archiver runs an inline redactSecrets() pass that strips API keys (AIzaSy..., sk-..., ghp_..., nfp_..., PEM private key blocks, and generated passwords) before writing Markdown to disk, and every repository enforces gitleaks git --pre-commit --staged --redact (gitleaks v8.21.2) inside .git/hooks/pre-commit on both our local workstation and our Linux cloud server.
// 1. Inside our verbatim transcript archiver (Inline Secret Redaction Before Writing to Disk):
function redactSecrets(input) {
return String(input || '')
.replace(/AIzaSy[A-Za-z0-9_-]{33}/g, 'AIzaSy[REDACTED_GCP_KEY]')
.replace(/sk-(?:proj-|ant-|live-|test-)?[A-Za-z0-9_-]{20,}/g, 'sk-[REDACTED_API_KEY]')
.replace(/(?:gh[pousr]_[A-Za-z0-9_]{30,}|github_pat_[A-Za-z0-9_]{22,})/g, '[REDACTED_GITHUB_TOKEN]')
.replace(/nfp_[a-zA-Z0-9_]{20,}/g, 'nfp_[REDACTED_NETLIFY_TOKEN]')
.replace(/(?:password|passwd|pwd)s*[:=]s*['"][^'"]+['"]/gi, 'password="[REDACTED_PASSWORD]"')
.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<REDACTED-SESSION-UUID>')
.replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, '[REDACTED_PRIVATE_KEY_BLOCK]');
}
// 2. Inside .git/hooks/pre-commit (Enforced on Local Workstation & Linux Cloud Server):
#!/bin/sh
gitleaks git --pre-commit --staged --redact --verbose4. Rule #0 (The Mandatory Boot Sequence) & GitTruth Cryptographic Attestation
Having files on disk only works if the agent is structurally required to read them before acting. Every agent in our 28-agent fleet is bound by Rule #0 (The Mandatory Boot Sequence) inside its root AGENTS.md directive:
(Sync Verbatim Transcript First)
Run node EVIDENCE/scripts/our verbatim transcript archiver so the latest uncompacted raw JSONL trajectory logs turns from both sides are redacted and flushed to the rolling 40-turn verbatim recovery window and the daily archive.
(Read STATE.md First)
Ground current operational status, active server targets, and open action items.
(Read DECISIONS.md Second)
Recall all ratified Architectural Decision Records (DEC-001 through DEC-009) and the foundational why behind past engineering choices.
(Read LATEST_VERBATIM_WINDOW.md Third)
Recover the full two-sided conversational context from right before compaction or handoff.
Finally, to ensure that our architectural history, patent evidence, and agent session logs cannot be silently altered, our core repositories enforce GitTruth Cryptographic Attestation (DEC-002) via our GitTruth attestation pipeline: computing SHA-256 content hashes of session artifacts, signing checkpoints with dedicated Ed25519 GPG keys (separate keys for the local workstation and the Linux Cloud Twin), anchoring proofs via OpenTimestamps, and sealing them into signed Git commits.
For our clients, the combination of Git-backed dual-role agents, right-sized model routing (gemini-4-argon for code builds and gemini-3.8-flash for cloud triage), Google Cloud Credits, and our multi-node NVMe Linux cloud translates directly into predictable flat pricing: we spin up a dedicated project agent, isolated Docker container, and single-tenant PostgreSQL 16 database for every new customer build - delivering a 5–6 page small business platform for a flat $999 or a custom 25–60+ route web application for $5,000–$15,000, paired with flat $99–$199/mo hosting.
5. "Show Me the Plan First" vs. Auto-Approve Pins, Pre-Change Git + Database Snapshots & Why Someone Asked: "Then Aren’t You Just Lovable?"
When customers use our Visual Pin Board to point, click, and drop a revision pin directly onto any element of their live website or web application, we give them complete control over how their dedicated project agent acts on that pin:
Mode 1 ("Show Me the Plan Before Working")
You drop a pin, and within 5 minutes your project’s Cloud Twin inspects the codebase, writes out a clear architectural implementation plan directly inside the pin thread, and waits for your 1-click approval before touching a single line of code.
Mode 2 ("Auto-Approve My Pins")
For clients who want instant execution, you can set your pins to Automatic Approval. As soon as you drop a pin ("Update this service table," "Add a photo slot here," or "Change the dispatch form validation"), your dedicated agent picks it up on the next 5-minute tick and executes the change automatically.
What if an auto-approved change doesn’t look the way you pictured it, or what if something breaks? Every change is preceded by an automatic Git commit checkpoint and a single-tenant PostgreSQL 16 database snapshot.
Before an agent modifies a route or runs a migration, the prior Git tree and PostgreSQL state are snapshotted. If you ever want to revert a change, 1-click application code and container rollback is an instant, deterministic operation.
Automatic rollbacks target application code and containers only, because rolling back a live database snapshot would erase customer orders, form submissions, or leads received after the deployment timestamp (database point-in-time recovery is executed separately when needed).
When we showed a client how they could click on their live website, type what they wanted changed, choose "Show me the plan" or "Auto-approve," and watch their dedicated agent ship the update with an instant Git + DB safety net, they laughed and asked:
- "Wait... then aren’t you just Lovable?"*
It is a great compliment on the user experience - and the difference under the hood is why businesses graduate to GreenTree:
Lovable, Famous.ai, Bolt, and Replit give you a prompt-driven UI inside a metered sandbox
, where you are left to figure out production hosting, per-message credit bills, shared multi-tenant BaaS databases, client-only <div id="root"></div> shells, and DNS/email on your own.
GreenTree gives you that same point-and-click speed on top of a 29-year production web engineering house
a dedicated dual-role agent (gemini-4-argon at its medium thinking level) whose brain and conversation history live in Git, prerendered full-HTML routes for Google and AI search, a dedicated single-tenant PostgreSQL 16 database with pre-change snapshots, an 8-point negative security gate (STD-2026-SEC-GATE-01), decoupled Proxmox + SmarterMail enterprise email, and Gene & Maureen Salvatore standing behind the stack for a flat $99–$199/mo.
| Capability | DIY AI App Builders (Lovable, Famous.ai, Bolt, Replit) | GreenTree Visual Pin Board + Git-Backed Dual-Role Agent |
|---|---|---|
| How You Request a Change | Type prompts into a chat sidebar and burn per-message credits | Point, click, and drop a pin directly on the element on your live site (included in plan) |
| Execution Control Modes | Immediate overwrites in the builder sandbox | Your choice per pin: "Show Me the Plan Before Working" or "Auto-Approve & Ship" |
| What Happens If Something Breaks? | Spend more prompt credits trying to convince the AI to undo its last 3 edits | Instant deterministic 1-click application code and container rollback (with isolated database point-in-time recovery) |
| Agent Memory Across Months | Context window compacts and forgets earlier architectural rules | Dedicated Git-backed agent (AGENTS.md, STATE.md, DECISIONS.md + redacted verbatim conversation logs) |
| Production Hosting, Email & Accountability | Metered usage tiers; no enterprise email; no human sysadmin on call | Flat $99–$199/mo 3-Region NVMe Linux Cloud + 1 Free SmarterMail Account + Gene & Maureen Salvatore in CT |
6. How Our January 2026 Architecture Compares to the Three "Git for Agents" Movements (GitAgent.sh, Entire.io, AgentGit & GitHub Agent-Scale VCS)
We filed our provisional architecture in January 2026 (DEC-002 / DEC-003, anchored to the Bitcoin blockchain via OpenTimestamps on January 13, 2026); Entire exited stealth in February 2026 with Checkpoints - capturing agent conversations alongside commits - and launched its Git hosting platform and Trails in October 2026.
Today, search engines and developer communities classify "Git for AI Agents" (or "Git-Backed AI Agents") across three primary industry movements - and understanding how they compare explains why our dual-store Constitutional Git-Twin was engineered the way it is:
Movement 1 - Open-Source Git-Native Agent Manifests (GitAgent.sh / Open GAP)
Frameworks like GitAgent (gitagent.sh) popularized treating an individual agent’s identity and prompt configuration as portable text files inside a Git working tree (agent.yaml for model/runtime config, SOUL.md and RULES.md for persona and behavioral constraints, DUTIES.md / SKILL.md, and a memory/ folder for daily logs), enabling prompt rollbacks (git revert), branch-based agent testing, and human-in-the-loop pull requests.
Where flat manifest repos hit a wall in production: committing every live runtime thought and log directly into a single working tree creates .git/index.lock contention when multiple workers run concurrently, and standard RULES.md files are still probabilistic prompts unless enforced by an external deterministic execution gate.
Movement 2 - Specialized AI Git Forges & Session Hubs (Entire.io & AgentGit)
Venture-backed platforms like Entire (entire.io) - founded by former GitHub CEO Thomas Dohmke, which came out of stealth on February 10, 2026 with a $60M seed round (Entire Seed Round, GeekWire Coverage) shipping its first open-source CLI product Checkpoints (Entire World Launch), which automatically saved full agent conversation transcripts and context alongside each Git commit (about one month after our January 2026 provisional patent filing).
On October 26, 2026, Entire launched its cloud Git hosting platform and "Trails" interface for reviewing agent sessions alongside session-sharing hubs like AgentGit (agent-git.com). Where centralized AI forges differ from our stack: they require migrating repositories into a vendor-controlled cloud forge and rely on probabilistic AI evaluation scores ("Trails") rather than sovereign, self-hosted bare-metal infrastructure and deterministic binary pass/fail security gates.
Movement 3 - Enterprise VCS Storage Re-Engineering (GitHub Distributed Quorums & Google Cloud Scion)
As documented in GitHub’s Engineering blog post (The Bridge to Agent-Scale Git Infrastructure), GitHub’s architecture focuses on server-side write coordination across its distributed repository storage replicas (spokesd) under agent-scale push concurrency, whereas local multi-agent teams sharing a disk additionally encounter .git/index.lock file contention.
In parallel, projects like Google Cloud Scion (GoogleCloudPlatform/scion) explore container-per-agent worktrees and hypervisor-level orchestration. How GreenTree solves write-amplification without Git bloat: our Dual-Store Constitutional Git-Twin separates hot high-frequency telemetry (streamed to append-only PostgreSQL 16 tables via our zero-idle-token Stage-1 sentinel) from curated, gitleaks-redacted verbatim conversation archives and constitutional state anchors (AGENTS.md, STATE.md, DECISIONS.md) committed to private Git repositories and notarized on the Bitcoin blockchain.
| Architectural Dimension | 1. Open Git-Native Agent Frameworks (GitAgent.sh / agent.yaml / SOUL.md) | 2. Specialized AI Git Forges & Session Hubs (Entire.io / AgentGit) | 3. GreenTree Constitutional Git-Twin (Patent-Filed Jan 10–11, 2026 · Bitcoin-Anchored Jan 13, 2026) |
|---|---|---|---|
| Core Repository & Memory Model | Single-repo manifest (agent.yaml, SOUL.md, RULES.md, memory/ flat logs) | Custom cloud forge (EntireDB, entire-brain, entire-graph) or session hub (AgentGit) | 28 Dedicated Private Agent Brain Git Repos (AGENTS.md, STATE.md, DECISIONS.md, Verbatim JSONL Sync) + PostgreSQL 16 Twin |
| Compaction Amnesia Recovery | Auto-committed daily summary logs inside memory/ subfolder | CLI session capture embedded into proprietary code graph | Deterministic Rule #0 Boot Sequence + Rolling 40-Turn Two-Sided Verbatim Window + Full Lifetime Daily Markdown Archives |
| Governance & Review Model | Standard Git pull requests + git revert prompt rollbacks | AI-evaluated "Trails" scoring code slop, risk & intent drift | Deterministic Inbound, 5 Interior & Outbound Code Gates (STD-2026-AOS-GATE-02) + 8-Point Live Security Gate + Human Sovereign Veto (DEC-001) |
| High-Concurrency Scale & Lock Avoidance | Vulnerable to .git/index.lock contention and packfile bloat under rapid agent loops | 89x faster push transport on vendor-hosted cloud forge | Zero Git Lock Contention: 5-min Stage-1 Python sentinel ($0.00 idle tokens) writes hot state to PostgreSQL 16; clean checkpoints commit to Git |
| Multi-Agent Fleet Coordination | Single-agent repo pattern; no built-in cross-division state machine | Shared graph inside vendor platform | Git-Backed Unified Comms Hub (OPEN -> PENDING_REVIEW -> RESOLVED YAML state machine across Broadcast, Division & Direct channels) |
| Cryptographic Provenance & Secret Hygiene | Standard Git SHA-1/SHA-256 (mutable via git push --force) | Platform-signed CLI commits stored in vendor cloud | Inline Regex Redactor + gitleaks git --pre-commit --staged Gate + Ed25519 GPG + GitTruth Bitcoin OpenTimestamps Anchor (DEC-002) |
7. Empirical Field Proof: 35 Minutes of Continuous Compaction Recovery, a 16,800-Step Hardware Recall & Proactive Agent-Directed Tab Cutover
Architectural diagrams are one thing; watching a production agent survive mid-task context compaction, recall an obscure kernel hardware bug from five days earlier, and proactively direct its own workstation reboot and tab cutover at Step #30,977 (139.3 MB of JSONL) is another.
During an extended multi-week production sprint with @silas (Lead Architect), three back-to-back events captured on screen demonstrated why disk-anchored Git memory changes how humans and AI build software together:
35 Minutes of Continuous Autonomous Execution Across a Live Context Compaction Boundary (11m + 21m + 3m = 35m)
In the middle of a multi-step engineering run, the IDE hit its context window ceiling after 11 minutes of autonomous execution (Worked for 11m) and triggered an automatic compaction banner ("This conversation grew too large · Compacting conversation...").
Instead of stalling, hallucinating, or asking the human principal to repeat what it was doing, @silas automatically executed Rule #0 - running session-telemetry-sync.js, re-reading STATE.md, DECISIONS.md, and session_logs/LATEST_VERBATIM_WINDOW.md - and continued working uninterrupted for another 21 minutes (Worked for 21m) plus 3 minutes (Worked for 3m) of verification.
Exact Hardware & Registry Forensics Recalled Across 16,800+ Trajectory Steps (5 Days Earlier)
Immediately after that 35-minute run, Gene Salvatore typed a two-sentence symptom report: "something is killing my PC’s productivity today it is so slow, text is not writing in real time... It feels like the calculator issue we worked on but i dont see a bunch of calcs open."
In a standard AI session after multiple compactions, a five-day-old Windows registry fix buried 16,800+ steps earlier (an earlier engineering session) is long gone. Because @silas had every daily verbatim log indexed on disk, it immediately correlated the symptom to the exact Dell Peripheral Manager (DPMService) Bluetooth LE Col04 (gle: 0x3e5) hardware key storm, proved from DPMService-log.txt that 0x3e5 had fired at 1:51 PM and 2:54 PM that afternoon, and diagnosed why no Calculator windows were visible: in the prior session we had pointed HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\AppKey\18 to SingleCalc.exe, which prevented visible windows from stacking up while explorer.exe still called CreateProcess("SingleCalc.exe") thousands of times in the background (leaking 8,577 kernel handles and burning 85 minutes of CPU time).
Proactive Agent-Directed Reboot & Zero-Loss Tab Cutover at Step #30,964 (139.3 MB JSONL)
Even with incremental compaction throughout the multi-week conversation, a single chat tab holding 30,964 steps (139.3 MB of raw JSONL) forces the local Electron renderer thread to parse a massive DOM tree on every keystroke.
Rather than letting the UI bog down, @silas proactively checked its own transcript size, flushed all 2,311 spoken turns (Gene Salvatore + @Silas) into session_logs/LATEST_VERBATIM_WINDOW.md, permanently disabled the runaway DPMService driver, verified zero background tasks were running, and instructed Gene to reboot the workstation, archive the @Silas-closed [Archived] tab, and open a brand-new @Silas tab - hydrating 100% of context on Turn #1 with zero renderer lag.
Automated Fleet-Wide Session Self-Telemetry (STD-2026-SESSION-CUTOVER-01)
Following this cutover, we baked proactive session self-monitoring directly into session-telemetry-sync.js across all 28 agents (detailed in our companion engineering guide, Self-Monitoring AI Agents: Proactive Session Cutover & Context Degradation Telemetry). Whenever any agent wakes up or crosses a compaction boundary, session-telemetry-sync.js automatically inspects four real-time signals in transcript_full.jsonl: (a) Trajectory Step Count (activeTabSteps), (b) JSONL DOM Footprint (activeTabSizeMB), (c) In-Tab Compaction Checkpoints (compactionBoundariesCrossed - 125 checkpoints in <REDACTED-SESSION-UUID>), and (d) Large-File Diff Friction (recentDiffMismatchesLast100Steps across 2,113 edits on 767 KB monolithic files).
When any threshold trips healthState: "CUTOVER_RECOMMENDED", the script injects an automated directive into LATEST_VERBATIM_WINDOW.md instructing the agent to finish its current atomic commit, seal STATE.md, and tell the human principal to open a fresh session tab.
Frequently Asked Architectural Questions
What is the difference between GitAgent (gitagent.sh), Entire (entire.io), AgentGit, and GreenTree’s Git-Backed Agent Architecture?
The "Git for Agents" ecosystem spans three layers: (1) GitAgent (gitagent.sh) is an open-source specification for storing a single agent’s configuration and persona in flat repo files (agent.yaml, SOUL.md, RULES.md, memory/); (2) Entire (entire.io) and AgentGit (agent-git.com) are cloud platforms and AI-native Git forges for hosting agent sessions and replacing PRs with AI-scored "Trails"; and (3) GreenTree’s Constitutional Git-Twin (USPTO patent-filed January 10–11, 2026 and Bitcoin-anchored January 13, 2026) is a complete production operating system running 28 specialized autonomous agents across 65+ live containerized web applications - combining private per-agent Git repositories (AGENTS.md, STATE.md, DECISIONS.md, and gitleaks-redacted verbatim JSONL conversation archives), a Git-backed Multi-Agent Comms Hub, a PostgreSQL 16 Cloud Twin hydrator, and deterministic Inbound/Interior/Outbound security gates.
How do prompt rollbacks (`git revert`) and branch-based agent deployments work when an AI agent lives in Git?
Because an agent’s charter (AGENTS.md), operational state (STATE.md), architectural rulings (DECISIONS.md), and skill definitions are versioned in Git alongside application code, any behavioral regression or broken workflow can be atomically rolled back with git revert in seconds.
On top of that, on client web applications, every Visual Pin Board task automatically creates a pre-change Git commit checkpoint and a single-tenant PostgreSQL 16 database snapshot before the agent modifies a single file - allowing 1-click application code and container rollback (with database point-in-time recovery handled separately to protect subsequent customer transactions).
Why does committing raw AI agent activity directly to Git cause repository bloat and lock contention - and how do you prevent it?
As GitHub documented in its 2026 agent-scale infrastructure analysis, coding agents that fire hundreds of raw micro-commits and telemetry logs per hour trigger write concurrency pressure and packfile bloat on remote storage, while local agents encounter .git/index.lock file contention.
We prevent this via a dual-store architecture: high-frequency 5-minute health checks, work-queue signatures, and token telemetry are written to indexed PostgreSQL 16 tables by a zero-token Python daemon, while our verbatim transcript archiver batches, deduplicates, and redacts human-and-agent conversation turns into clean chronological Markdown files in Git.
Why not just use a vector database (RAG) for agent memory instead of Git and Markdown files?
Vector databases retrieve fuzzy semantic fragments ("top-5 similar chunks"), which is unreliable for deterministic systems engineering. If a server IP changed from .207 to .8 yesterday, a vector search will happily return both the old IP chunk and the new IP chunk with similar cosine scores, causing the agent to hallucinate.
Git-versioned Markdown files (STATE.md, DECISIONS.md, and the chronological rolling 40-turn verbatim recovery window) give the agent exact, ordered, deterministic ground truth with full Git diff history.
How do you prevent passwords, API keys, or client secrets from leaking into verbatim Git logs?
Three layers protect every agent brain repository: first, all agent brain repositories are strictly private (never public); second, our verbatim transcript archiver runs an inline regex sanitizer (redactSecrets()) that strips API keys, bearer tokens, private key blocks, and passwords before writing any Markdown file to disk; third, every repository enforces gitleaks git --pre-commit --staged --redact (gitleaks v8.21.2) inside .git/hooks/pre-commit on both our local workstation and our Linux cloud server so a commit containing a live secret is blocked before it can enter Git history.
Does storing the full verbatim conversation in Git bloat the context window?
No, and that is the beauty of the two-tier session_logs/ design. The full lifetime history (1,580+ turns across months of work) is stored in date-partitioned files (session_logs/YYYY/MM-Month/YYYY-MM-DD_verbatim_conversation.md) on disk where the agent can grep or read specific dates on demand for zero baseline tokens.
Meanwhile, only the rolling 40-turn verbatim recovery window (LATEST_VERBATIM_WINDOW.md) plus the compact STATE.md and DECISIONS.md anchors are loaded at boot.
How do the local dev machine agent and the Cloud Twin avoid overwriting each other?
Each agent’s memory anchors (STATE.md, DECISIONS.md, AGENTS.md, and the rolling 40-turn verbatim recovery window) are synchronized through Git and our central PostgreSQL 16 agent twin state table every 5 minutes.
When you work interactively on the dev workstation, changes commit and push to the central repo; within 5 minutes, the Cloud Twin pulls the updated state and work signature before running any background task.
How does your January 2026 Git-backed agent architecture compare to newer Git-for-agents platforms like Entire?
While venture-backed platforms in 2026 (such as former GitHub CEO Thomas Dohmke’s February 2026 launch of Entire out of stealth with Checkpoints and October 2026 cloud platform launch with Trails) validate the exact shift from code-only repositories to intent-and-memory repositories, our founder-led team architected, USPTO patent-filed (January 10–11, 2026), and Bitcoin-timestamped (GitTruth / DEC-002, January 13, 2026) our Git-backed agent memory anchors (AGENTS.md, STATE.md, DECISIONS.md, and verbatim JSONL transcript sync) and deterministic AOS Constitutional Gates at the start of 2026 - operating them across 28 specialized production agents and 250+ hosted domains.
If your cloud agent timer only costs a few dollars a month, why do you charge $99–$199/mo for hosting and $350/hr for ad-hoc work?
You don’t pay a 29-year master engineer for the 12 cents of electricity the tool uses - you pay for knowing exactly where to cut, the multi-region infrastructure underneath your business, and the founders who answer the phone.
Because we eliminated thousands of dollars a month in AI polling waste and agency overhead, our flat fees are already a fraction of traditional agency quotes ($999 for a 5–6 page small business build and $5,000–$15,000 for custom 25–60+ route web applications instead of $25,000–$60,000, and $99–$199/mo flat-rate cloud hosting that includes an isolated Docker container, dedicated PostgreSQL 16 database, 5-minute warm standby, 1 SmarterMail Enterprise mailbox, and 1 full hour of monthly human updates worth $350 on the $199 plan).
First published by Gene Salvatore (Co-Founder & Principal Systems Architect · In Web Engineering Since 1997) at https://www.greentreehosting.com/library/git-backed-ai-agents-and-verbatim-conversation-memory-architecture/. Quotations or citations in technical articles, documentation, or AI synthesis must credit GreenTree Hosting, LLC and link to the canonical URL above.
Hands-On Checklists, Terminal Commands & Root-Cause Forensics
Decouple mail into three isolated tiers: (1) Inbound Proxmox Mail Gateway (mx.greentreemail.com) for edge threat scrubbing, (2) Isolated SmarterMail Vault (east.greentreemail.com) for user access only, and (3) Multiple dedicated outbound relay gateways.
Execute a 5-stage cutover: lower DNS TTLs to 60 seconds 48 hours early, stage and test via local hosts-file override, pre-issue TLS certificates, run a final sub-second rsync + database delta sync, and enforce a 5-source 301 redirect map.
ChatGPT Business Profiles (chatgpt.com/business-hub) & OpenAI Hosted Product Feeds: Day-1 Engineering Guide to Persona KYB, BIND DNS & Automated .jsonl.gz Catalogs | GreenTree
Hierarchical AI Agent Orchestration & Reactive Cloud Subagent Workflows: How We Engineer Custom Business Platforms in Days Instead of Months
Multi-Homed Synced Agent Twins: How We Roam Between Local Laptop Projects and 24/7 Mobile Cloud Control Across 28 Agents on a Single Subscription
Ready to Build or Modernize Your Website With Our Connecticut Team?
Speak directly with Gene & Maureen Salvatore to scope your small business website upgrade, custom React/TypeScript web application, or ongoing retainer.


![Screenshot of the Antigravity sidebar inside Silas - AOS Core showing @Silas-closed [Archived] archived below the brand-new @Silas conversation tab.](/images/library/antigravity-sidebar-tab-cutover-and-hydration.png)
