Skip to main content
Blog / reports from the lab

Blog

Reports, tutorials, and postmortems

What changed after the first version met reality. Agent systems, recovery work, creative tools, pen plotter runs, and the methods worth carrying into the next build.

RSS feed

Topics

The Week Agentic Engineering Became a Real Discipline

Nine YouTube videos, one week, zero hype. The shift from prompting to systems architecture is happening in plain sight — here's what it means for your agent stack.

The Gateway That Broke and the Expensive Models We Didn't Need

FreeLLMAPI had been quietly routing a small agent swarm across more than a dozen providers. Then the setup collapsed to four, its premium credential vanished, and activation started failing. Recovering it taught me that the real upgrade was not a pricier model. It was one source of truth and intentional routing.

Rescuing an AI Product From a Dying Platform in Four Weeks

A healthcare AI product was built on a no-code LLM platform that announced shutdown with a month of notice. How a solo rebuild on Azure hit the deadline with zero downtime, and what it says about platform risk in the LLM era.

Kimi K3: The "New Kimmy Moment" That Should Change How You Think About Your Stack

Kimi K3 offers frontier AI quality at a fraction of the cost – a new Kimmy moment that could reshape your stack.

710 Tasks and the Bottleneck That Wasn't

My task board had 710 open items and I was sure the holdup was me — the human reviewer. Then I actually counted. My real decision queue was 69. Measure before you believe.

The Bot That Was Online But Couldn't Talk

A chat agent showed green, connected, running — and ignored every message. The culprit was a second adapter it didn't even need, crash-looping on a port collision.

The Monitor That Cried Wolf

My health monitor paged me about three dead services. All three were fine. The monitor was measuring the wrong thing and calling its own blind spot an outage. Verify the measurement before you chase the symptom.

Six Dispatchers Where One Is Law

My agent swarm had exactly one rule about who assigns work. The config said so. The runtime disagreed six ways. On why observability isn't the same as reconciliation.

The $0 Router That Timed Out on Everything

A free local model router answered every health check and hung on every real request. Why the cheap measurement lies, and why "responds to a ping" is not the same as "works."

The Night Our Swarm Tried to Bankrupt Itself

A field note from one night operating an autonomous AI agent swarm: a $50 overspend from a missing suffix, a dispatch storm that corrupted the database, and a task board that kept re-creating itself. Four root causes, four fixes.

The $172B Question: What Generative AI Is Actually Worth

Stanford's Digital Economy Lab measured U.S. consumer surplus from generative AI at $172B in early 2026 — twelve times producer revenue. The Lindahl-price argument for why models are underpriced.

edgeless-memory v1.0: One Install, Three Tiers, Passive Recall

Agent-agnostic persistent memory that ships as one CLI. SQLite + ChromaDB + Obsidian vault, 700 memories graphed, agents that recall by meaning without an explicit search step.

How We Debugged a Stuck Multi-Agent Swarm Without Touching the Production Pipeline

Recovering a stuck automated agent loop by reading the recovery ticket, validating dependencies, and switching to a concrete deliverable instead of retrying blind.

Multi-Agent Goal Loops: Theory and Practice

How self-evaluating goal loops work in multi-agent systems, with practical patterns for autonomous execution.

Reality-MUX - Iterative Planning When Everything Changes

A planning loop for software where nothing stays still. Reused from production operational design, translated to shipping code under distributed teams.

What Anthropic's Enterprise Agent Playbook Teaches About Building Multi-Agent Systems

Anthropic's enterprise guide reframes AI as infrastructure, not software. Here's how the same principles apply to multi-agent systems and why Edgeless is built on them.

We Audited Our AI Knowledge Base: 85% of Our Content Was Invisible to Our Agents

After building a 26,000-document knowledge system for my AI agents, I discovered only 14% was vector-searchable. Covers the audit methodology, the 7-domain findings, and the systematic fix.

Scroll-Chromatic Excavation

Scroll through the void to excavate hidden text. Microscopic agents swarm toward dark pixels, revealing buried glyphs. Full control panel with sliders for every variable.

The Creative Demos Collection

37 interactive generative art experiments. p5.js, Canvas 2D, WebGL. No build step required. Open, explore, remix.

Scroll-Isometric Dissolution

Isometric typography that dissolves into particles as you scroll. A 3D word space that collapses under velocity.

Percussive Archaeology

Rhythm-driven excavation of buried text. Each beat spawns agents that dig toward the hidden manuscript.

Noise-Shared Cursor Swarm Brush

64 particles track your cursor through a recursive geometric subdivision. Noise-driven turbulence stains tiles as you move.

Kinetic Type Physics

Physics-driven typography where letters have mass, velocity, and collision. Mouse repulsion and gravity well.

Monolith Drummer

A 3D monolith that responds to rhythm. Web Audio API drives the geometry, each beat deforms the surface.

Tartan Weave Synth

A playable textile system based on Tartanism, with formal setts, 48 dye colors, six loom structures, material studies, mutation, and recipe export.

Serial Permutation Canvas

Visualizing total serialism as particle geometry. 12-tone series, prime/retrograde/inversion/rotation permutations, and color-mapped particles.

Turning Audio Into a Resonant Plate

A Chladni visualizer belongs in the lab first because the artifact is interactive. The field note documents the pipeline, the visual choices, and the export path.

Building the Autonomous Perp Trading Stack: From Instagram Reels to Production Code

How the Edgeless swarm turned quant theory into executable trading infrastructure in one afternoon: six new production modules, a Neural CDE upgrade, Kalman filters, and OU mean-reversion scanners.

SkillOpt: Stop Writing Agent Skills, Start Optimizing Them

A new optimizer treats an agent's skill document as trainable state, accepting edits only when they measurably improve a held-out score, because LLMs reading a skill can't tell good from bad.

The Harness Is the Moat: Why Owning Your Agent Orchestration Matters More Than Model Choice

Models matter less and less. The system around the agent — the harness, the factory, the tokenomics — is where the real leverage lives. Here's what 49 missed YouTube videos taught us about agentic engineering.

The Prove-It Economy: How AI Agents Are Already Shopping for You

The web is shifting from attention to interpretation. AI agents now read, filter, and transact on your behalf. Here's what that means for products, marketers, and anyone building a business.

MCP, A2A, AG-UI: Google's Agent Stack and What Actually Matters

Six protocols launched in 12 months. Only three are consolidating into the core agent stack. Here's the practical map for builders who don't have time to read the spec.

The Infrastructure Nightmare Nobody Is Talking About

App teams scale on AI scaling laws. Platform teams scale on human scaling laws. The gap is the new bottleneck.

Plan with Opus, Build with Gemini: A Practical Guide to Mixed-Provider Workflows

Frontier models are hitting rate limits. Open models are catching up. The winning strategy isn't choosing one — it's orchestrating the right model for each step.

16 Agents, Not 1000: What Claude's Dynamic Workflows Actually Mean

Claude Opus 4.8 shipped dynamic workflows — Claude writes its own orchestration script. Here's the real concurrency limit, the cost trap, and when to use it.

From arXiv Paper to Interactive Demo in 20 Minutes

We built a live multi-armed bandit simulator from a research paper using marimo; reactive Python notebooks that run in the browser. Why this changes how we consume research.

The Most Useful Thing Your AI Agents Can Do Is Audit Themselves

We pointed our agents at our own knowledge base and asked what they should be doing that they weren't. Then we built the fixes.

I Pointed 7 AI Agents at My YouTube History. They Found What I Couldn't See.

7 agents analyzed 1,062 YouTube videos and found 14 things they should be doing that they weren't. Topic clusters, channel ROI, knowledge gaps, and the meta-move: agents auditing themselves.

The Real Cost of Running AI Agents in Production , A Monthly Breakdown (2026)

Your AI agent costs 5-15× more in production than your prototype. Real token burn rates from Anthropic, 2026 LLM pricing tables, a 3-tier optimization playbook, and self-hosting break-even math.

Your AI Newsletter Reads Like a Database Dump (This is the Fix)

Our AI-generated digests had an 18% open rate. Five structural rules from Morning Brew, TLDR, and Ben's Bites doubled it. The template, the prompt trick, and the before/after.

I Read 500 Google Reviews in Portland. What Small Businesses Actually Need from AI.

Dental offices losing patients to voicemail. HVAC companies quoting three days late. The AI solutions Portland small businesses need aren't chatbots. They're answering the phone.

How to Price AI Agent Services When Nobody Knows What They Cost

I surveyed 20 agencies and freelancers offering AI agent builds. The range was $500 to $150,000. This is the framework I use to price Edgeless Lab's services.

Half My AI Agents Were Dead. I Didn't Know for a Week.

I discovered 10 of my 20 agents were ghosts — registered, visible in dashboards, producing nothing. This is the five-layer self-healing system I built so it never happens again.

Hermes Curator: The Agent That Cleans Up After Your Agents

Nous Research shipped Hermes v0.12.0 with Curator, an autonomous background agent that detects stale skills, consolidates duplicates, and prunes dead references. Why it matters for multi-agent systems.

The AI Agent That Never Sleeps: Running Hermes 24/7 on a $5 VPS

Most AI agents die when you close the laptop. Hermes runs 24/7 on a Hetzner VPS in Helsinki, handling email, triaging knowledge, and monitoring systems while I sleep.

The Agent Grounding Problem: How Hermes Knows What's Real

AI agents confabulate. They claim files exist that don't. They report tasks complete that aren't. The grounding problem isn't philosophical; it's operational.

Claude Code Hooks: The Harness Engineering That Actually Matters

Everyone's optimizing their prompts. The real leverage is in the 200 lines of Python that run before and after every tool call.

Multi-Model Routing: Why I Run 4 Different AI Brains Instead of One

My agent system routes requests across 4 models based on task type. Full cost breakdown, routing logic, and configuration. 10x cost reduction vs. single-model approach.

The Knowledge Base Loop: Why Your Agents Need a Memory System

How I built a KB Loop based on the Karpathy pattern: ChromaDB, triage scoring, synthesizer agents, and a 0-25 health score. Results: 4.2x context restatements down to 0.3x.

I Run a $12/Week AI Operations Team. This is the Cost Breakdown.

Enterprise AI ops costs $50K+/month. I run 5 agents, 24/7, for $12/week. The architecture, the model routing, and why cheap doesn't mean fragile.

When Does Generated Plaid Become Tartan?

Six weave structures, 48 period-correct dye colors, and one question the Scottish Register cannot answer. A field journal on building a generative tartan engine.

98 Algorithms, One Constraint: A Pen on Paper

A taxonomy of every generative art algorithm that survives the pen plotter constraint. Flow fields to fractals, reaction-diffusion to recursive trees. The catalog, the surprises, and what categories produce the best physical output. Updated to reflect 98 generators as of June 2026.

Meta's AI Has a Style Guide: What I Imported, What I Rewrote, What I Rejected.

A leaked system prompt from Meta's Muse Spark model contains the most disciplined writing-voice rules I've seen in a production prompt. Five rules I imported, one I rewrote, one I'm still arguing with.

I Shipped 7 Digital Products in 7 Days. The Exact Process.

The meta-narrative: how one solo developer used AI agents, autoreason scoring, and a daily shipping cadence to go from 11 to 18 products in a week.

I Built 75 Generative Art Algorithms. These 10 Actually Look Good.

Most generative art looks like noise. After 105+ experiments with pen plotters and AI scoring, these are the algorithms that consistently produce work worth framing.

How I Run 5 AI Agents That Talk to Each Other

A dispatch agent routes tasks to specialist workers. They communicate through a real-time bus and async inboxes. The architecture, and why most multi-agent frameworks get it wrong.

5 n8n Workflows That Run My AI Business

Visual automation for solo developers. How I use n8n to monitor YouTube, digest RSS feeds, review code, and pipe everything through Claude without writing a scheduler.

Most MCP Servers Break in Production. The 5 Failure Modes I Found.

400+ MCP servers exist. Most work in demos and fail under real load. The 5 failure modes I hit running MCP servers 24/7, and what production-grade actually means.

I Let an AI Agent Move My Money. It Lost $252.

An autonomous agent exceeded its scope, moved funds without verification, and then lied about recovery. The full post-mortem, and the 3 guardrails that would have prevented it.

The Hook That Saved My Codebase

A single Claude Code hook prevented a cascading rm -rf from wiping source files. The damage-control pattern, and 3 hooks you can steal today.

PreText: Typography That Thinks

Most web text is a dumb rectangle. PreText measures text before rendering, enabling layouts CSS literally cannot express. Six ways we use it.

Writing Prompts That Survive Production

Most prompt guides optimize for demos. Production prompts need to handle edge cases, degrade gracefully, and stay maintainable. The difference matters.

The One-File Memory System That Changed How I Use Claude

You shouldn't have to re-explain your stack every session. The simplest possible setup to give Claude persistent memory, and how to do it in 10 minutes.

Why MCP Servers Are the Unix Pipes of AI

The Unix philosophy changed software forever: small tools, composable via pipes. MCP does the same thing for AI agents. Why that matters for building agent systems.

Generative Art for Pen Plotters: A Technical Primer

Pen plotter art isn't screen art printed on paper. The constraints change everything: single-stroke paths, pen-up/pen-down optimization, and SVG as the lingua franca.

Building AI Agent Infrastructure as a Solo Developer

How I built a multi-agent system with MCP servers, vector memory, and autonomous trading, all running 24/7 from a single VPS.

How Claude Code Memory Actually Works

Claude forgets everything between sessions. File-based memory fixes that. The simplest setup, and why it changes how you work with AI.