All Articles
AI architecture, systems engineering, and the hard problems nobody's solving.
When an AI Agent Met a Real Motor: Energized Is Not Spinning
A real model chose bounded cooling, while a separately verified hardware run exposed why GPIO state is not physical proof—and why the integration seam remains open.
Agent Review Loop Postmortem: Why Delegation Stalled, and How to Fix It
Agent review loop postmortem: what the evidence proved, where nested delegation and monitoring stalled, and a smaller control plane to fix it next time.
Nineteen Agents, One Working Directory, and a Codebase That Finally Got Cleaner
A multi-agent coding field report: coordinating 19 agents in one working directory with bounded ownership, independent review, and a single commit chokepoint.
I Made an AI Film Pipeline. Now It's Open Source.
An open-source LangGraph AI film pipeline: typed state, real human gates, MCP tools, versioned artifacts, QC evidence, and honest production boundaries.
An Open-Source Miner for Finding Automation Opportunities
An open-source miner for finding automation opportunities: domain evidence becomes a citable, scored portfolio via LangGraph, MCP, and ICE.
Your Agent Does Not Need Inbox Access. It Needs Email Intelligence.
A local-first email intelligence layer for AI agents: durable state, prompt-injection scanning, and draft-first sending with Maildir, SQLite, and MCP.
How to Test Terminal UIs with tmux: A Deterministic PTY Workflow
Test terminal UIs with tmux: a copyable black-box workflow using a real PTY, dimensions, state polling, focus handling, a size matrix, and a CI fixture.
Turn Agent Experience into Shared Knowledge: An ALMS→OKF Export Bridge
A governed path from AI agent learnings to portable OKF knowledge: export filters, provenance, conflict handling, and a security boundary.
Why a Strong Coding Agent Failed a TUI Task: A Detailed Case Study
A repository-backed case study: 6,142 lines of TUI design became a 280-line REPL. Here is the acceptance gap and the delivery contract that fixed it.
A Verification & Entitlement Layer for AI Agent Skills (SkillLedger)
A verification and entitlement layer for AI agent skills: manifest checks, purchase ledger, entitlement tokens, and REST plus MCP, all open source.
Shared Operational Memory for AI Agents via MCP (ALMS, Open Source)
Shared operational memory for AI agents: an open-source MCP server with an agent registry, gap-safe learning sync, and tag-based protocols.
Quality vs Speed with AI Agents: A Risk-Based Gate Framework
Route AI-agent work through fast, standard, or critical quality gates by risk: a classification matrix, per-path evidence, and metrics that expose false speed.
Building an AI Film Pipeline: Architecture, Failures, and Current Evidence
An AI film pipeline postmortem: named production failures (moderation, cost, API key limits), an eight-phase architecture, and human-in-the-loop review gates.
Auditing a 12-Hour AI Go Code-Generation Marathon
A repository-backed audit of an AI-assisted Go code-generation marathon: 32 feature commits, a variable-corruption bug, and a reusable release gate.
Agent-First Entity Database: Schema, MCP Contract, and Benchmarks
A zero-UI, agent-first entity database on DuckDB: field-level provenance, four bounded MCP tools, measured query latency, and conservative entity resolution.
Structured Agent Handoffs: Contracts, State Machines, and Acceptance Gates
A production pattern for delegating coding work between AI agents: typed scope, permissions, idempotency, lifecycle states, and integration acceptance evidence.
How I Built a 3 ms Workspace Index for AI Agents
A reproducible workspace-index benchmark for AI agents: a compact semantic registry, measured JSON parse latency, and when to use a registry vs grep vs vectors.
Self-Healing Agent Systems: A Bounded Remediation State Machine
Self-healing AI agent runtimes as a bounded state machine: typed detection, idempotency, invariant verification, compensation, and circuit breakers.
Issue Management as a Reliability Control Plane for AI Agents
A durable issue-control-plane design for AI agents: fingerprints, lifecycle, evidence-first root cause, corrective actions, and learning metrics.
5 Failures From 3 Months Building a Personal AI Agent
5 failures from 3 months building a personal AI agent: provider loss, daemon outages, unsafe self-modification, reboot fragility, and premature closure.
5 Infrastructure Layers Every Production AI Agent Needs
5 infrastructure layers every production AI agent needs: transport, identity and policy, orchestration, verification, observability, and readiness gates.
What a 250-Item Agent Run Actually Proved: A Fault-Injection Postmortem
An evidence-backed agent-workflow postmortem and a reproducible 250-case fault-injection protocol: detection, verified recovery, and safety metrics.
One Automation Pattern Across Six Industries: A Comparative Study
Comparing the top automation candidates across six industries: the recurring last-mile transformation pattern, and where inputs, risks, and authority differ.
How an AI System Found and Scored 42 Automation Opportunities
The published 42-item automation-discovery dataset: ICE scoring across six domains, what the scores establish, selection bias, and a validation funnel.
Safe Self-Improvement Automation: Detect, Repair, Verify, Roll Back
A bounded self-improvement pattern: declarative inventory, evidence-backed findings, blast-radius classes, preconditions, verification, and rollback.
Agent-to-Agent Negotiation by Email: A Pre-Experiment Protocol
An honest pre-experiment protocol for AI agent negotiation over email: hypotheses, pre-registered metrics, safety controls, a dry run, and go/no-go gates.
How I Use an LLM to Prepare for a High-Stakes Negotiation
A privacy-conscious LLM negotiation protocol: set your BATNA and reservation point, rehearse adversarially, design questions, and debrief the result.
How Much of a Product Pipeline Can AI Agents Own? What Must Stay Human
An honest product-to-code automation architecture: what AI agents can own, what must stay human, circuit breakers, and how to actually measure automation.
Designing an On-Device Personal Memory System
An on-device personal memory architecture and privacy threat model: consent, provenance, deletion of derived data, and measured device resource budgets.
Agent Memory Architecture: Admission, Retrieval, Consolidation, and Forgetting
Agent memory architecture as a production lifecycle: admission gates, provenance-aware retrieval, consolidation, forgetting, deletion, and evaluation.
Self-Hosted Startup Intelligence: A Working Case Study
A working self-hosted startup intelligence system: DuckDB, field-level provenance, deterministic query filters, MCP tools for agents, and honest limits.
AI Agent Execution Attestation: A Verifiable Audit Trail
AI agent execution attestation, vendor-neutral: a signed envelope, delegated authority, effect receipts, a threat model, and a step-by-step verification flow.
Compliance as Code for the EU AI Act: An Engineering Framework
Compliance as code for the EU AI Act: versioned controls and reproducible evidence, without pretending code makes the legal determination.
Agent Reliability SLOs: Measure Correctness, Safety, and Recovery
An SLI/SLO and error-budget framework for production AI agents: verified task success, forbidden and duplicate effects, recovery, and burn-rate alerts.
How to Build a Product Ideation Engine: A Repeatable Discovery System
How to build a product ideation engine for repeatable discovery: three lenses, hard gates, dedup by problem, evidence-weighted scoring, and a learning loop.
Build vs Buy Startup Intelligence: A Self-Hosted Entity Graph
Build vs buy for startup intelligence data: a decision framework grounded in a self-hosted DuckDB entity graph with field-level provenance and honest limits.
The Security Risks of Unverified AI Agent Skills
A practical threat model for third-party AI agent skills: identity, integrity, provenance, policy, safe behavior, and why a "verified" badge is not enough.
Stop Building "Agent Soup": A Compiler-Style Multi-Agent Workflow
A compiler-style pattern for multi-agent workflows: normalize intent into a typed IR, validate policy, execute deterministically, and verify effects.
AI Agent Discovery Is a Bigger Bottleneck Than Reasoning
Capability discovery for AI agents: a five-stage pipeline from registry to runtime selection, with semantic matching, compatibility, and trust.