Pete Guzzo
AI Engineering & Operational Intelligence
This page was built
by the system it describes.
CORTEX is the operational intelligence system I've been engineering around modern AI agents. It gives specialized agents persistent context, defined responsibilities, supervisory oversight, verification, learning and human approval gates — so they can work together without every new session starting from zero.
This page became one of its own projects.
Research, source verification, content architecture, writing, engineering and QA were distributed across specialized agents under CLM supervision. The work was reconciled against prior project history, verified before implementation, and kept offline until I approved the result.
AI agents are powerful, but most of them still walk into the room like it's their first day.
You give the agent a task. It executes. It forgets.
The next session starts exactly where the first one did — at zero. If last Tuesday's bug taught you something, you're the one carrying that lesson. The agent isn't. This is where most AI-assisted work lives.
You write it down. A README. A setup doc. A prompt template.
Better. But documentation captures what you remembered to write, not what actually happened. It doesn't record the three things you tried before finding the one that worked. It tells the agent what you planned. It doesn't tell the agent what the project learned.
Before the session ends, you write down where you left off.
Real progress. But the handoff is only as good as what you remembered to include. The notes age. They go stale. They're written by a human who is also doing the work — which means they're incomplete by default.
The system that stays.
CORTEX operates as an experienced supervisor who never leaves the project. It accumulates verified experience across every session — what broke, what the last agent tried, what was confirmed to work, and why. The next agent doesn't start from zero. It starts from a verified operational baseline.
Reflex rules are earned from real incidents, not written from theory. Session handoffs are structured, not improvised. Memory files are human-readable, editable, and scoped per project. If a lesson is wrong, you edit the file. No retraining required.
"The model's weights are unchanged. The model's effective behavior improves because every new session starts with a richer, verified operational context."
CORTEX Project Journal
How this page was made
This page is one of the case studies.
It didn't get handed to a single agent with a blank prompt. It went through the same operational system it's describing.
Live wall and control room infrastructure — Shear Media Studios, Tampa
The work
Real projects. Real engineering.
These are not demos. Each one is a deployed system with a documented operational record.
Operational Intelligence
peteguzzo.com
The problem
73 pages. 50 work items. 10 articles. Three prior field agents had already conducted audits. None of them made a single production change to the live site. All findings went through CLM before any implementation was authorized.
The engineering
Soft 404 problem discovered: every unmatched URL returning HTTP 200. AI/LLM discoverability assessment: AI could answer "Who is Pete Guzzo?" but only generically — the specific facts weren't structured for machine consumption. Five authority pillars defined. Full implementation plan written as self-contained, delegatable task bundles.
What changed
A complete roadmap with zero production changes. Every recommendation traceable to a verified finding. The next agent that runs the implementation has a specific, bounded task — not a blank page.
Production Engineering
Heights Lounge CMS
The problem
A Tampa kava bar needed to manage their own website: events, schedules, brand colors, content. The engineering stack — Next.js, TinaCMS, Cloudflare Pages, an AI auto-fill worker — had to be completely invisible to the client.
The engineering
14 operational rules earned from real incidents — not written from theory. The tina-lock.json 3-key sync pattern: learned from two separate schema mismatch incidents, now a reflex rule. Boolean toggle bug: documented, workaround applied, not rediscovered. SEO removed from CMS after causing the original mismatch — reflex rule: do not add it back. AI auto-fill via Cloudflare Worker. Auto-deploy: push to GitHub → Cloudflare rebuilds.
What changed
Complexity in engineering, simplicity for the client. The 14 earned rules mean the next engineering session doesn't pay for any of those discoveries again.
SEO + AI Discoverability
peteguzzo.com + Shear Media Studios
The problem
AI systems could describe Pete correctly but generically. The specific facts that distinguish him weren't structured for machine consumption. At Shear Media Studios, 20 SEO articles needed systematic development with correct entity architecture and structured data.
The engineering
5-pillar authority framework. Every page mapped to an authority pillar before copy. llms.txt gap analysis. Person schema gap analysis. Seven specific AI discoverability questions answered from structured files. For Shear: three-file source structure per article (.md + .json + .schema.json). When Squarespace clipboard paste failed — two-strike confirmed — ClipboardEvent dispatch developed and implemented: bypasses the system clipboard entirely.
What changed
AI discoverability treated as a design constraint from the start — not an afterthought. A methodology that scales: same three-file structure and claims verification protocol across 20 articles.
Supervised Infrastructure Engineering
Live Broadcast Connectivity Test
The problem
A multi-party live broadcast test spanning three separate control domains. Multiple experienced engineers asserted the required configuration was impossible through a specific network path. The team did not accept this as a verified constraint.
The engineering
Full topology reconnaissance before any change. Device address stabilized before downstream dependencies were created. A single narrowly scoped change — nothing adjacent touched. The engineers' assertion was classified: VERIFIED (tested against this system)? DOCUMENTED (published by a controlling authority)? Or ASSUMED from prior practice? It was ASSUMED. Tested with the smallest reversible experiment the topology allowed.
What changed
All feeds and the return path succeeded. Expert opinion was treated as valuable evidence, but not as a substitute for verified system behavior. The constraint classification framework captured as a CORTEX reflex.
Architecture
A supervisory network — not a chatbot.
CORTEX operates as a Collective Learning Mainframe: a persistent supervisory layer that synthesizes field-session experience into verified operational doctrine, governs agent behavior within defined boundaries, and maintains institutional knowledge across every project. It is not autonomous. It is supervised.
Control room infrastructure — the physical layer beneath the operational intelligence layer.
CORTEX / CLM
Governance · Memory · Learning · Approval
The supervisory layer. Retains project context. Synthesizes lessons from all field sessions. Defines agent boundaries. Holds human approval gates.
Field Agents (Claude Code)
Browser · CMS · Execution
Specialized agents assigned to specific tasks. Each operates inside a defined scope. Findings reported to CLM at verified checkpoints.
Codex
Code · Schema · Architecture
Technical specialist. Schema design, structured data, technical SEO, repo inspection. Registered August 2026.
TENTACLES V0 — current operating model. Manual checkpoint file exchange. Sessions write structured handoffs; CLM reads at defined checkpoints. Not a live network connection — a disciplined operational protocol.
TENTACLES V1 (heartbeat infrastructure) and Ruflo (orchestration) are designed but not yet active.
The learning loop
Field agents encounter real conditions and document findings.
Lessons meeting the evidence standard flow to CLM at checkpoints.
CLM synthesizes. Verified lessons promote to canonical doctrine.
Next agent starts with accumulated context — not from zero.
How it actually works
External memory beats internal training
— for this class of problem.
Machine learning improves by changing the model. Retraining. Weight updates. The learning is inside the system, which means it's opaque, expensive to correct, and impossible to scope per project.
CORTEX improves by changing the context. External state files. Verified incident records. Reflex rules earned from real failures. Every lesson is human-readable, editable, and scoped to the project that generated it.
| Dimension | Machine learning | Persistent Operational Learning |
|---|---|---|
| Learning mechanism | Weight updates via training | External state files |
| Memory location | Inside the model | Human-readable files |
| Auditability | Opaque | Fully visible |
| Editability | Requires retraining | Edit a text file |
| Project isolation | Not possible | Memory scoped per project |
| Error correction | Requires retraining | Delete or update the rule |
| Evidence requirement | Statistical patterns | Incident-specific, traceable |
| Explainability | Limited | Every action traceable to source |
AI that learns through retraining is a black box. The learning happened. You can observe the changed behavior. You cannot read the lesson, correct it, or scope it to one project without affecting all the others.
AI that learns through accumulated external memory is an audit trail. The lesson is a text file. You can read it. You can edit it. You can delete it if it was wrong. You can see exactly which incident generated it, what the evidence was, and who confirmed it.
The organization should not have to pay for the same mistake twice.
What I design and build
This is not "I use AI to work faster." This is the architecture of how AI-assisted work gets structured, governed, and made reliable over time.
Operational intelligence infrastructure
The memory layer: state files, session handoffs, reflex rules, incident logs — structured so knowledge accumulates instead of evaporating. Designed per project, not applied as a generic template.
Multi-agent coordination
Field agents with defined scopes. Technical agents with specific capabilities. Routing logic that assigns tasks to the right agent. Governance gates that hold the right decisions for human approval.
AI-assisted workflow integration
Not "use Claude for this task" — but "design the system that uses Claude correctly for this class of task, with the right oversight and verification checkpoints." The workflow, not the prompt.
Supervised autonomy design
What agents can do autonomously. What requires a recommendation and human decision. What requires explicit human approval before any action is taken. The governance layer that makes AI work trustworthy — not just capable.