OpenClaw & Hermes Fleet Engineering
We build, audit, harden, and operate OpenClaw and Hermes agent fleets. We run our own fleet in production every day. We can do the same for yours.
Many agent fleets are built by conversation. Someone talks to the agents until the system works. The demos look good. Then the problems appear: high API spend that no one can explain, daily firefighting, memory and session errors, and an email pathway with no security. The agents still deliver real value. But the system has no engineering underneath it.
We supply that engineering. We run our own multi-agent platform on OpenClaw and Hermes, and we operate client fleets beside it. Together that is more than 50 agents under daily management. These agents produce research, content, and operations 24 hours a day. We build new fleets correctly from day one, and we repair existing ones. If you want the results without owning a fleet, use our Managed Autonomous AI Agents service. This page describes the engineering practice underneath that service.
Our method is determinism. Determinism means the system uses fixed code for fixed tasks, so the output is the same every time. We move every task that does not need an LLM into plain code. We put gates and structured state around the LLM calls that remain. We scope every permission. We screen every call. This gives you a fleet with a lower error rate, less hallucination, lower cost, and behavior you can predict, inspect, and audit.
50+
Agents we manage every day
250+
Scheduled daily agent jobs
30+
Failure types we protect fleets against
WHAT WE ENGINEER
The Engineering Behind the Agents
We apply these nine disciplines to every fleet we build or take over.
🔍
Fleet Audits & Cost Forensics
We map every agent, skill, cron job, and dependency in your fleet. We show where every API dollar goes, broken down by agent, by model, and by job.
🎛️
Workflow Control & Determinism
We move work that does not need an LLM into plain code and gated workflows. This raises accuracy, reliability, and compliance. It also cuts spend, because plain code does not use model tokens.
🛡️
Security & Injection Screening
We build screening for every prompt and LLM call. This protects against prompt injection, bad actors, and incorrect operations. We also scope each agent’s permissions to the minimum it needs.
🕶️
Privacy Engineering
We add LLM dehydration and re-hydration. Sensitive data is removed from a prompt before it leaves your systems. The data is restored locally when the response returns. Your operations stay private.
🔀
Model Provider Strategy
We set up many model providers, not one. We route each job to the model that fits it. We can switch providers without rework, and we can move the right workloads from frontier APIs to local inference.
🧠
Model Training & Fine-Tuning
We train open-source models with fine-tuning and LoRA. This specializes a model for your domain, your voice, and your data. A smaller, cheaper model can then do work that used to need a frontier model.
⚡
On-Demand GPU Clusters
We build high-powered GPU systems in clusters. We spin them up, run training or batch jobs, and spin them down. You pay for compute hours, not for idle hardware.
🔧
Hardening & Ongoing Ops
We harden fleets for observability, resilience, reliability, security, and oversight. We maintain the servers, handle daily issues, run system upgrades, and oversee continuous improvement.
🧩
New Agents, MCP & Integrations
We build and train new OpenClaw and Hermes agents. We build and manage custom MCP (Model Context Protocol) services. We connect the fleet to your external tools and platforms.
HOW IT WORKS
From Audit to Ongoing Operations
Every engagement starts with a written assessment. The assessment contains a full map of the fleet, a breakdown of where the money goes, and a remediation roadmap. A non-technical owner can read it. After the assessment, we do the work, and we keep doing it.
Where the Money Goes
These are common findings. A polling cron calls a model every five minutes and finds work in 4 percent of runs. A frontier model is assigned to a job that a shell script could do. An agent re-sends its full history on every call, so token spend grows every week. We break spend down by agent, by model, and by job. Then we move the work that belongs in code into code.
Why the Fleet Misbehaves
Memory files grow large and load on every invocation. State is kept in prose documents instead of a database. Two skills do the same job with slightly different behavior. Instructions are re-explained in chat for months instead of being engineered into the agent once. These are some of the common root causes of unpredictable agent behavior.
What Can Hurt You
An inbound email pathway has no injection screening, and it feeds an agent that holds write-capable tools and shared credentials. A script catches its own errors, exits clean, and reports success while its output degrades. A cost drop looks like a win but is a failure: spend fell because completed work fell. Our audit playbook checks for more than thirty failure types like these. We found most of them in our own fleet first, so we know what they look like.
WHY THESE FRAMEWORKS
OpenClaw, Hermes, or Both
OpenClaw and Hermes are not competitors. They are different layers of the same stack. The right architecture often runs both.
OpenClaw
OpenClaw is built around a Gateway: one control plane that routes work between agents. Each agent runs isolated, with its own workspace, scoped tools, and scoped permissions. Use OpenClaw when the work is a multi-stage workflow that must stay predictable and inspectable.
Both, Nested via ACP
Most production systems need both: OpenClaw for containment, Hermes for reasoning. The two connect over the Agent Communication Protocol (ACP). We have run this nest in both directions.
Hermes Agent
Hermes is built around a learning loop. The agent executes a task, evaluates the result, extracts a reusable skill, and recalls it on future work. Use Hermes when the value lives inside one agent’s reasoning, and the agent must get smarter at your domain over time.
Our full guide covers the architecture decision, including the cases where you should use neither framework and write plain code instead: Hermes Agent vs OpenClaw: When to Use Which (and When to Use Both).
PROVEN IN PRODUCTION
Where We Have Run These Fleets
We have built and operated OpenClaw and Hermes fleets for these functions, on our own systems and on client systems:
✓ Content production pipelines
✓ SEO and GEO research
✓ Thought-leadership research
✓ Self-directed software development
✓ Personal assistance
✓ Site building
✓ Content writing
✓ Editorial processes
✓ Digital experience management
✓ Data collection and transformation
✓ Broad research initiatives
✓ The systems that connect them
These fleets run on physical Mac Mini and Mac Studio machines and on AWS cloud instances. Some run on their own. Some are embedded inside larger workflow systems. Hermes has worked for us in two roles: as the director of other agents, and as the specialist agent inside a structured workflow loop. Hybrid routing is part of the work. We decide what runs locally on your hardware, what runs as plain code, and what needs a frontier model API call.
RELATED SERVICES
Fleet engineering is one part of how we work with AI. One of these related services may fit your need better:
Managed Autonomous AI Agents: We run agent systems for you and deliver the outcomes as a subscription. Choose this if you want the results without owning the fleet.
Agentic Development: AI agent teams build custom software under senior direction. This is the same discipline, applied to one-time builds that you own.
AI Agent Platform: Our packaged platform. Specialized production agents work together through a single orchestration layer.
AI Risk & Security Assessment: A focused security review of your AI systems. It covers prompt-injection exposure and permission scoping.
Agentic Coding Training: We train engineering teams on agentic workflows and multi-agent orchestration, so your own team can work this way.
Frequently Asked Questions
Put Real Engineering Under Your Agents
Tell us about your fleet, or the fleet you want to build. We will scope an audit or a build. We will tell you honestly what should run on an LLM, what belongs in code, and what it should cost.
