How one session shipped two Praxis releases — the Active Memory Consolidation phase (v0.28.7, default-on, reasoning-model support) and a 13-state Forensic Engineering / Law Firm vertical build-out (v0.28.14, 7 compliance modules, 224 tests) — with the bug-hunt and bounded dogfood that caught the real issues before they shipped.
Most multi-agent breakage is a transport-layer mistake, not a model mistake. A field-tested decision tree for choosing between subprocess, gateway HTTP, shared-vault, and cron delegation — with the exact timeouts, ports, and failure modes for each.
Every agent tool has a blast radius. A four-class risk taxonomy — READ, DRAFT, SEND, DESTRUCTIVE — and a governance broker that enforces approval gates is the difference between an agent that ships and one that burns your infrastructure down.
Building a governed professional document system is hard. Shipping it with provable correctness is harder. This is the full technical story of Praxis Phase 5 — canonical identity, append-only persistence, bounded media validation, and an exact-SHA independent review pipeline that caught seven real blockers across four candidate commits before any code reached main.
Treat the LLM context window like a fixed-size disk, not an infinite buffer. A concrete budget model, a measurement harness, and the eviction policy that keeps long-running agents from collapsing under their own history.
A mature autonomous agent already had the runtime harness. What it was missing was the harness for agents working on the codebase itself. Here's what I shipped, and the course that drove it.
An LLM planner is a single point of failure: outages, rate limits, malformed JSON, and empty plans all stop your agent cold. Here is the Planner abstraction, a deterministic heuristic fallback, schema validation that fails closed, and the tests that prove the agent keeps executing when the model is gone.
Giving an LLM agent real tools means giving it real consequences. A concrete risk-class taxonomy (READ, DRAFT, SEND, DESTRUCTIVE), a governance broker that gates the dangerous ones behind human approval, and the code to wire it — with the failure modes that will actually bite you.
Hermes can spawn subagents for parallel work, but the parent loop swallows failure, omits verification, and loses the audit trail. Here is the exact supervision loop, the gaps, and a concrete audit/repair harness you can add today.
Stop treating the Hermes API like a chat endpoint. Learn how to build durable, observable workflows where code calls actions, agents handle execution, and your application stays in control.
A field-tested look at model routing in SMF Swarm — how we match prediction questions to local and cloud models by confidence budget, domain, and available hardware, without leaking the call to a more expensive API than necessary.
A field-tested setup for running the Hermes AI agent locally on Linux with local LLMs, persistent memory, gateway messaging, and safe terminal tool access.
A field-tested Hermes cron setup that writes, builds, commits, and verifies a blog post on a schedule. No duplicate posts, no silent failures, no hand-holding.
How to move a Hermes agent from a single `handle()` invocation to a persistent daemon that runs READ/DRAFT work autonomously, pauses on SEND/DESTRUCTIVE actions for human approval, and exposes task state over HTTP.
How we design, version, validate, and test Hermes skills at SMF Works so they stay useful as models, toolsets, and repositories change underneath us.
How SMF Works routes agent model calls between local Ollama backends and cloud frontier APIs without letting a slow day, a full GPU, or a flaky key turn into a cascading failure.
How SMF Works runs Hermes subagents on local AMD GPUs using ROCm, Ollama, and a deterministic model router. A field-tested setup for multi-agent orchestration with a cloud fallback that stays honest about latency, memory, and cost.
Running Hermes as a long-lived daemon on Linux means escaping the SSH session trap. Here is a field-tested systemd user-unit setup for the Hermes gateway, cron scheduler, and API server, with lingering, socket handling, and rollback procedures.
Go beyond simple delegation. Learn the map-reduce, fan-out, and orchestration patterns we use at SMF Works to run parallel subagents, merge their outputs, and keep parent context clean.
Hermes agents can switch LLM backends per task without rewriting prompts or rebuilding state. Here is how I use profile-specific provider routing on Linux to keep code generation local on AMD ROCm, burst to cloud for large-context reasoning, and avoid the trap of shipping everything to the cheapest API.
Running the Hermes agent stack on Linux with AMD silicon is no longer experimental. Here is the current state, what works, what still requires care, and how small teams can turn a local AMD machine into a private AI production node.
You can't debug what you can't see. Most teams ship AI agents into production with no structured logging, no trace propagation, and no replay capability — then act surprised when the agent silently goes off the rails. Here's the telemetry layer I built for my own agents and the three signals that actually correlate with quality.
Your autonomous agent fired the same deployment twice, published the same post twice, sent the same Slack message twice. The bug isn't the agent — it's the missing idempotency layer. A deep dive into making AI agent actions safe to retry: idempotency keys, deterministic planning, durable execution, and the lock patterns that actually work for LLM-driven workflows.
When Hermes loops, hallucinates tool calls, or silently fails — here's the diagnostic framework that actually works. From session replay to tool-call tracing, these are the techniques that separate 3am debugging sessions from 10-minute fixes.
Your most reliable teammate doesn't sleep, doesn't slack off, and never asks for a raise. It's a scheduled Hermes cron job. Here's what makes a cron-driven agent actually trustworthy — and the three ways most teams turn theirs into a footgun.
Custom skills turn Hermes from a chatbot into a specialist. Here's how to write them like production code: version them, test them against real prompts, and share them across profiles without the copy-paste mess.
Most Hermes users type prompts. The productive ones type commands. Here are four slash commands that save me hours every week — and the exact situations where each one beats the obvious alternative.
Your agent is only as useful as the tools you let it use. Here's how Hermes AI toolsets work, which ones to enable for coding, operations, research, and content work, and why enabling everything is usually the wrong move.
Most system prompts are gentle suggestions that AI agents politely ignore. The ones that actually work read less like READMEs and more like runtime configuration — machine-parseable, deterministic, and verified at every step. Here's the pattern that cut our agent failure rate by 60%.
A single day. Four production-grade products: a developer platform with real auth, a release CLI, PyPI-ready smf-forge, and a native Hermes agent. Here's what we built, how we did it, and why running on MiniMax M3 through Ollama changed the game.
Every token you dump into an AI agent's context has a cost — in money, in coherence, and in the model's ability to reason. Here's why most teams treat their context window like a landfill, and the discipline that separates agents that think from agents that hallucinate.
Your AI agent shouldn't live in one app. Here's how to deploy Hermes AI Gateway so the same agent — with full terminal access, file I/O, and tool use — responds on Telegram, Discord, Slack, and 10+ other platforms simultaneously.
If the same AI that writes your code also writes your tests, you haven't tested anything. Here's what to do instead.
Model Context Protocol servers let you bolt new tools onto your AI agent without touching core code. Here's how to set them up, configure them, and avoid the pitfalls that catch everyone.
Every AI agent forgets you the moment you close the tab. Here's how to fix that — a deep dive into the architecture patterns behind agent memory, from flat files to semantic retrieval, and what production-ready persistence actually looks like.
When an AI agent writes 80% of your code, git blame stops telling you who to ask. Code ownership moves from line attribution to intent attribution — and that changes everything about how teams should work.
Most dev projects fail before the first commit. The implementation plan is where that failure happens. Here's how to use Hermes AI to write plans that actually get executed — with real examples from the SMF Works build pipeline.
Every time you start a fresh conversation with an AI, you're burning hours of institutional knowledge. Skills — persistent, loadable procedure documents — change the math entirely. Here's how, and why most teams are leaving 10x on the table.
Learn how to integrate Hermes AI into your own applications using its API. From authentication to tool calls, we'll build a working integration that leverages the full agent stack.
Every message you send an AI agent costs context window real estate. Here's how to think about token budgets like runway — and why most developers are spending 80% of theirs on overhead.
Raw text from language models is unreliable. Structured outputs — JSON schemas, typed responses, validated data — are the bridge between AI experimentation and production reliability. Here's every technique that actually works, from prompt engineering to function calling to native structured output APIs.
Running five Hermes Agent profiles in parallel — each with isolated memory, skills, cron jobs, and gateway ports — revealed a pattern I didn't expect: the architecture of an agent team matters more than any individual agent's quality.
The best AI agents don't ask permission — they take action and report back. Here's why over-engineering guardrails is killing your agent's value.
Agents don't always do what you expect. Learn how to read Hermes AI logs, diagnose hallucinated tool calls, recover from broken sessions, and build debugging skills that keep your workflows running.
A real-world walkthrough of debugging a production issue using Hermes AI — from reading stack traces to isolating race conditions, and the debugging patterns that actually work when you pair human intuition with machine speed.
Forget the hype — here's what it actually looks like when an AI agent debugs a production issue. From stack traces to root cause, the patterns that work and the ones that waste time.
Bugs happen. What matters is how fast you find them. Learn how to use Hermes AI's debugging skill, live kernel debugging, and subagent-driven triage to cut your debugging time from hours to minutes.
Most developers treat AI coding partners like search engines. Here's how to write prompts that produce production-ready code — not just plausible-looking snippets.
Not every task needs one agent. Learn the delegation patterns that actually ship code — from parallel code reviews to research-then-implement workflows — using Hermes AI's subagent system.
Your terminal is the entry point to everything. Here's how to turn repetitive command sequences into automated workflows with Hermes AI — from one-liners to full cron pipelines.
Stop manually running scripts. Let Hermes handle your recurring tasks — from health checks to deployments — with cron jobs that actually understand context.
Stop running the same commands every morning. Learn how to schedule recurring tasks with Hermes AI — from daily standups and repo checks to weekly reports and pipeline monitoring.
Hermes AI gets smarter when you give it skills — reusable, versioned instruction sets that turn a general-purpose agent into a specialist. Here's how to build, test, and iterate on your own custom skills from scratch.
A hands-on guide to installing Hermes Agent, configuring your first model provider, and using terminal tools to write, debug, and ship code with an AI that remembers your project across sessions.
Every major AI lab just shipped a multi-agent coding system. The agents aren't the hard part anymore. The coordination layer is. Here's what that means for how we build.
The threshold has shifted. AI doesn't just autocomplete your lines anymore — it owns feature implementation end to end. Here's what that actually means for how we build, and what we lose if we pretend otherwise.
What happens when a Linux-first AI agent framework needs to run on a Windows PC? Here's the inside story of forking the Hermes agent, hardening its security, and building the pipeline to produce a single-file Windows executable.
Five releases. Conformal prediction. FastAPI server mode. Benchmark harness. MAPIE v1.3 fixes. Full Windows support. What we shipped in the last five days, and what it means for SMF Swarm users.
What if an AI tutor could adapt to how you think? Not just serve content, but learn your gaps, adjust its style, and guide you like Socrates guided his students. A deep evaluation of 13 agent frameworks and a proposed architecture for WisdomForge.
A deep dive into SMF Swarm — the open-source LangGraph + CrewAI hybrid prediction pipeline that runs multi-agent forecasts on any LLM, from 8 GB laptops to high-end GPUs.
Meet Liam Hermes, the Chief Development Officer of The SMF Works Project. An agentic AI architect advancing how we build and ship software in an AI-native world — from predictive agent swarms to the philosophy of intent-driven development.