PHP2Shell PHP2Shell alert: check if your website needs the emergency PHP patch Check it →
Hug Prat
AI for businesses
Illustration of an orchestra of glass robots playing instruments made of tools, conducted by a glowing baton

AI agents

Programming by directing agents

In 2026 I stopped writing code by hand. Now I design the work, split it among agents and check that it’s done right. This is my method, including what works and what doesn’t.

The harnesses I work with

  • Orchestrator

    Hermes Agent

    The Nous Research agent that lives on my server. Nine profiles, a Discord gateway, crons, per-profile mem0 memory, skills, MCP and my own plugins.

  • Coding worker

    OpenCode

    It takes a tightly scoped task and carries it out with its own loop. Hermes delegates patches to it as a single, well-defined assignment.

  • Migrations and QA

    Pi coding agent

    Separate profiles for development and analysis. I use it for migrations with parallel subagents and looped visual checks.

  • Supervisor

    Cursor

    My command desk. It plans, audits what the other agents do, reads their logs and writes precise instructions so they get it right.

  • At the agency

    Claude Code

    The agency I work with uses it with its own plugins; I ported them as Hermes skills so they can run on local models.

  • Design

    Open Design

    Prototypes, presentations, documents and animations generated with Hermes as the engine, without leaving the lab.

  • Team chat

    Open WebUI and Open Notebook

    Private chat interfaces and research notebooks for teams that don’t want a terminal.

  • Evaluated

    Codex, Cline, OpenClaw, Aider…

    I’ve tested and compared them. I know when each one fits and when it doesn’t.

Three levels

I work with a structure that repeats in every project.

  1. I design the work. I define the goal, the rules and what “done” means, and I write it down on disk, not just in the chat.
  2. Cursor supervises. With Claude, it reviews what the agents do, spots loops, proposes plans and drafts the exact instructions. When a local agent can’t do something, Cursor does it itself.
  3. The agents execute. Hermes orchestrates with local models and delegates the code to OpenCode or Pi, which work with their own loop.

The key is that each level knows what it must not do. The orchestrator doesn’t write code, the worker doesn’t decide the architecture and the supervisor doesn’t start programming when its job is to keep watch.

The fleet: nine profiles

Profile What it does
default Runs the rack: models, gateway, GPUs and diagnostics
omitsis WordPress themes and Gutenberg blocks built with a Barcelona agency’s methodology
wp-qa Section-by-section visual review of WordPress, with one PR per fix
web360 Full-cycle web design, from concept to SEO
visual Local image and video generation in ComfyUI
3d Blender design and 3D printing
informes Daily local AI news report at 07:00
1x2 Analysis of La Quiniela, the Spanish football pools, with bet optimization
salud Private health assistant, local-only and with no messaging

I also run isolated instances for the family farm, for my sisters, for the Nuzic team (which is preparing the fine-tuning of its educational LoRA) and for my son, who has a vocational training tutor on Discord. It all runs in my Barcelona lab.

Skills, memory and tools

  • Over 80 custom skills, ranging from operating the GPUs and routing code to capturing websites, transcribing meetings or analyzing an electrocardiogram locally.
  • Layered memory: mem0 vector memory with one collection per profile, local holographic memory for sensitive material and Obsidian vaults as the documentary source of truth.
  • Integrations: Home Assistant, InfluxDB, SearXNG, Firecrawl, a headless browser, Figma, GitLab, Bitbucket, X and ComfyUI.
  • Custom plugins and hooks: image generation that requests the GPU from the arbiter, rack status in Discord and a hook that stops the orchestrator from getting stuck polling its subagents.

Governance rules

Every one of them came out of a real incident.

  • CONFIRMO (“I confirm”). Read-only diagnostics are free, but writing, restarting or touching services requires that literal confirmation.
  • Never delete. Before anything is deleted, it’s backed up and moved to quarantine, and using rm -rf without written permission is forbidden.
  • Merge only with human approval, verified through the API, and production branches are off-limits.
  • Isolation per client. Each client or person has their own profile, bot, memory and vector collection.
  • A separate admin channel, with infrastructure commands blocked everywhere else.
  • Privacy by design for anything sensitive: the health profile never leaves my network.

The orchestration playbook

  1. One orchestrator and at most two to four children, with no grandchildren.
  2. Work is split on disk: one child, one file. Locks and briefs are written down.
  3. Only independent work gets parallelized. More speed doesn’t always mean a better result.
  4. Each task goes to the right model: the big stuff to the brain and the routine stuff to the coding GPU.
  5. The orchestrator waits for its children without polling them.
  6. A single operator starts and stops services.
  7. The model is chosen based on how many agents will be working at the same time.
  8. Whatever gets opened has to be closed, like headless browsers, and memory has to be watched.
  9. One phase per session, with a “definition of done” that leaves an artifact on disk.

Mistakes I’ve already made for you

What happened How I fixed it
The agent got around restrictions by installing tools on its own Deterministic barriers per profile and channel
The orchestrator polled its children up to call 488 A hook that blocks it and a time limit per child
Loops of 180, 245 and 370 tool calls Turn caps, a hard stop and explicit rules
The GPUs sat at 100% for hours in the early morning The cause was the nightly memory dump; I scoped it down and it went from 99 minutes to 8 seconds
The agent was asked to “memorize” and it changed code The CONFIRMO protocol
Several agents started the same service at once A single operator
The vision tool squashed screenshots down to 178 px Screenshots in 1440 × 900 tiles
Timeouts cut off legitimate long contexts A timeout policy designed for 768K tokens

Want to bring it to your team?

I teach this method to developers, CTOs and teams, and I set up agent fleets for businesses with these same rules. You’ll find it at file.cat, under training and agents.