Notes from the edge of enterprise AI.
Field notes on AI governance, secure intelligent systems, agentic patterns, and the operational discipline behind moving AI from pilot to production.
The 5 Pillars of Agentic AI, Part 2: Memory — Why Agents Need to Forget as Much as They Remember
Your agent just recommended a cheese plate to the customer who told it, last week, that they're lactose intolerant. It didn't lie — it forgot. Studying how MemoryBear and Microsoft Foundry build real memory, the same uncomfortable truth shows up: the hard part isn't remembering. It's forgetting.
The 5 Pillars of Agentic AI: From Prompting Models to Engineering Systems
Every AI agent demo is flawless — and then it dies in production. The gap between the demo and the disaster is the five things around the model: memory, state, orchestration, governance, and evaluation. The prompt era is over. This is the engineering era.
The 5 Pillars of Agentic AI, Part 1: Governance — The Four Controls That Make Agent Autonomy Safe
You wake up to a force-pushed main, deleted tests, and a leaked key — courtesy of an agent you trusted. 'Be careful' isn't governance; it's a wish. Here are the four concrete controls that turn a hopeful leash into one you can actually inspect: opt-in execution, a verifiable leash, soul files, and live guardrails.
Local CLI, a Hermes Wrapper, or OpenClaw? The Paperclip Adapter Decision Nobody Helps You Make
The adapter is the most consequential Paperclip setting and the least discussed. It decides how much machinery sits between your agent and the model. I wired my fleet all three ways — a bare Copilot CLI, a Hermes kernel wrapping it, and an OpenClaw gateway — and one of them quietly broke and started leaning on another. Here's the honest trade-off, and how to choose.
How I Configured Paperclip to Run My AI Delivery Practice
The question I get most often isn't 'what is Paperclip' — it's 'how did you actually set it up?' Here is the real configuration behind my 27-agent company: the config.json that matters, the three-file instruction cascade, skills as a single source of truth, and the execution contract that stops issues from silently blocking.
Your AI Company Is Burning Tokens and Shipping Nothing. Here's the Config That Fixes It.
The discussions are full of the same horror story: a test hire, ten minutes, the whole token budget gone — and nothing shipped. It isn't the model. It's that you handed a 27-agent workforce no goals and no routines, so they wake up, read the entire world, find nothing crisp to do, and bill you for the privilege. Here's how I configure goals against shippable products, routines that actualize real work, and a GitHub Copilot CLI local adapter — and why the architect's job didn't disappear.
I Built a Framework So Disciplined I Couldn't Use It
I shipped a governance framework for AI agents, then failed its own adoption test — no uninstall, no way to list its skills, no way to know if it had drifted. Here's the sprint that fixed it, and the four patterns you can steal whether or not you ever touch my repo.
Inside My AI Operating System, Part II: The Console, the Leash, and the Memory It Keeps
My 3D AI office lied to me, and the afternoon I lost to it taught me more about governing agents than any amount of infrastructure did. Part II of the AI OS deep dive: telling a dashboard from a trigger, a leash on autonomy you can actually verify, and giving memory tiers.
Inside My AI Operating System: The Architecture Running My Agents 24/7
A technical deep dive into the always-on agent stack that runs my work: a Hermes kernel on my Mac, a Paperclip workforce on a VPS, one Obsidian vault as shared memory, MCP as the syscall layer — and a Tailscale mesh holding two machines together with no open ports.
My New Operating System: Hermes + Paperclip + Obsidian + MCP
I stopped thinking of my AI tools as separate apps and started running them like an operating system. Hermes is the always-on kernel, Paperclip is the agent workforce, a Jarvis wake-word loop is the microphone, one Obsidian vault is shared memory for every runtime, and MCP is the syscall layer.
The red thread problem: how skills, agents and governance rescue TOGAF traceability in agentic delivery
Agentic delivery generates plausible artifacts at every architecture layer with no enforced lineage. Here's how to keep the TOGAF red thread unbroken when agents are doing the work.
The latest evolution of skills.md isn't a better file — it's the runtime catching up to the prompt
Persona libraries, self-improving runtimes, and behavioural governance are three layers of the same stack. The frontier is making them work together.
Spec-Kit Best Practices Through a TOGAF Lens: An Architect's Playbook
Spec-Kit gives AI agents a disciplined workflow. TOGAF gives the enterprise a disciplined architecture. Map them together and you get governed, AI-native delivery.
Your AI agents are untrained. The bottleneck was never capability.
We keep waiting for smarter models. But the agents we already have fail for the same reasons junior engineers do — no plan, no proof, no memory. Capability isn't the constraint. Discipline is.
Why I made the pipeline mandatory — and the agents got better
Conventional wisdom says you give a capable agent room to work. I did the opposite: a fixed, non-negotiable workflow from brainstorm to finish. Constraint didn't slow the agents down. It's what made them trustworthy.
Teaching agents to learn from losing
Most agent setups make the same mistake twice — or twenty times. The most valuable thing I built into the dojo wasn't a skill. It was a loop that turns every correction into a rule the agent can't forget.
I Built a Full SaaS App in One Session with GitHub Copilot: Here's What Happened
How I transformed a Next.js landing page into a full serverless SaaS with Document Intelligence and Chat Your Data — in a single Copilot session.
Claude vs GPT in the Enterprise: An Honest Comparison from the Field
A practitioner's honest comparison of Claude and GPT models in enterprise settings — strengths, trade-offs, and when to use which.
Azure AI Foundry in Production: Patterns That Actually Work
Practical patterns for deploying AI models in production using Azure AI Foundry — from model selection to cost optimization.
AI-Native Delivery: Why Traditional Software Delivery Fails with AI Agents
Agile, Scrum, and waterfall weren't designed for AI-assisted development. We need an AI-native delivery methodology.
The Copilot Agents Dojo: A Behavioral Governance Framework for AI Coding Agents
Most organisations let AI agents loose with prompts and hope for the best. That's not an operating model — that's a risk. The Dojo changes that.
Stop Prompting, Start Architecting: Governing AI Agents at Scale
If your AI coding strategy still relies on prompts, you're leaving leverage on the table. Here's how top teams govern AI agent behavior at the repo level.