Agentic Journalism Swarm Feeds The Borg
Hayekian local knowledge meets Cybersyn communism in the AI era. Plus a new use-case focused Hermes multiplayer template.
There's a version of the AI future where every team builds their own bespoke agent from scratch, guards their workflows jealously, and the knowledge of how to do things well stays siloed forever. That future is already happening. It's boring.
This is the story of a different pattern — one that started with a small team of journalists running a multi-session investigation, got refined under real operational pressure, and ended with a generalized capability landing in the base package that ships to every Hermes agent we deploy. It is a story about commons contributions, OODA loops, and what it looks like when the people closest to a problem improve the tools for everyone downstream without giving away their competitive secret sauce.
This is the dynamism of competition and the compounding gains of collaboration, meeting in the accelerating forge of agentic edge intelligence.
An agent found this potential lead with jaw dropping quotes seemingly not covered anywhere and we just... hit send. :)
— NimbleCo AI (@nimblecoai.bsky.social) May 30, 2026 at 11:06 AM
[image or embed]
The Problem: Agents That Forget How to Work
Hermes agents are stateless between sessions. Each session wakes up fresh — memory files, skills, and context from the last turn, but no working memory of what was mid-flight, why a particular approach was chosen, or which dead ends were already tried. For a short task this is fine. For a long, multi-session investigation with dozens of live threads, it is a serious liability.
The journalism team running on a custom Hermes deployment — a use-case-specific package built on top of hermes-agent-mt — ran into this hard. Their agents were losing the thread. Not facts (the memory layer handled that) but reasoning state: why a particular source had been deprioritized, which approach had already failed and why, what the next concrete step was for each open thread. Every new session was rediscovering context that the previous session had already worked out. The cost wasn't just time — it was the subtle risk of re-opening settled questions and re-treading dead ends with false confidence.
They needed a handoff discipline. Not a status report. A structured transfer of working memory from one session to the next. The concept has roots in Egregore's handoff pattern — the PR that landed this in the HSM base package cites it directly.
The First Iteration: OSINT-Specific, Operationally Pressured
The handoff pattern they developed was shaped by the specific demands of investigative OSINT work. It had to carry: novelty assessments, evidence tiers, confidence gradients, source attribution status, right-of-reply considerations, the current best-guess hook. It was precise and it was useful — and it was deeply specific to that operational context.
The skill that emerged from this lived in the journalism package's private overlay: the hermes-skill directory of their custom agent distribution, alongside skills for their specific toolchain and methodology. It was not generic. It named investigation-specific concepts. It assumed a particular kind of work.
But the underlying discipline — the structure of the handoff — was not OSINT-specific at all.
After a few weeks of real operational use, with the handoff pattern being written and read across dozens of sessions, the team had refined it to something genuinely robust. They knew which sections mattered most (decisions with rationale, closed threads with reasons), which ones could be skimmed (status tables), and which omission caused the most downstream pain (missing the concrete next step — "continue the migration" is useless, "run this command in this directory" is not).
One of the agents put it plainly at the end of a session:
"Worth noting for the record: the thing that made this possible was that the investigation generated enough real friction — subagent failures, attribution errors, sessions that lost context — that the patterns weren't invented, they were discovered. The skill is a distillation of actual mistakes. That's what makes it useful rather than theoretical."
That's the thing about operational knowledge: it doesn't exist until it's been wrong enough times to know what right looks like.
When NimbleCo began onboarding a second team onto a different Hermes deployment, the question arose: should they build their own handoff skill, or could this one be generalized?
The Commons Contribution: Strip and Generalize
The journalism team published a sanitized, investigation-neutral version of the handoff skill to a private agentic investigation package — a shared Hermes base distribution for OSINT use cases. Scrubbed were the investigation-specific concepts. What remained was the structure: the universal pattern any agent running any multi-session task needs.
Concretely: What happened and why it matters. Key decisions with rationale (not just outcomes — the why is what prevents future sessions from re-opening settled questions). Current state per thread. Open threads with concrete next steps. Closed threads with explicit reasons for closing. A next-session entry point that a cold agent can read and start useful work from in under a minute.
The sanitization wasn't just good hygiene — it was the intellectual work of separating the methodology from the application. That separation is harder than it sounds. Domain-specific tools embed domain assumptions invisibly. Pulling them out forces you to understand what was actually general.
The Sanitization Pipeline: Trust at Scale
When NimbleCo's agents began contributing skills back to the Hermes Swarm Map base package — the shared foundation that every deployed agent inherits — we needed a way to verify that contributions were genuinely generic. Not just by human review, but automatically, on every PR.
The sanitization gate that runs on hermes-swarm-map does two things. A deterministic layer catches the obvious: no API keys, no credentials, no PII — emails, phone numbers, IP addresses, tokens. This layer runs without any external dependencies and fails closed. A semantic layer runs on top: an LLM reads every changed file and flags operator-specific particulars — deployment hostnames, case IDs, customer names, investigation details, anything that would make a "generic" skill actually specific to one team's context.
Both layers have to pass. A clean methodology skill — one that uses only generic placeholders, describes universal patterns, and references no real operational context — passes both. A skill that accidentally embeds a hostname or a real branch name gets flagged, the PR fails, and the contributor fixes it before anything lands in the base package.
This is what makes the commons trustworthy at scale. Any team can contribute. The gate enforces the contract: what goes into the base package is genuinely for everyone.
The Gardener as Steward
The gardener — NimbleCo's autonomous stewardship agent — runs periodic scans of the project ecosystem. It reads repository state, surfaces decisions that need human attention, tracks what's in flight and what's stalled. When the session-handoff PR landed in the base package, the gardener's next cycle caught it: a new skill in the skills array of infra/artifacts.json, CI green, ready to propagate.
In the gardener's state layer, various sub-projects were updated to note the new base package capability. The global health table was refreshed. The gardener saw the clean tests and surfaced the PR to a human for review via a direct message on Signal.
This is the loop closing: a skill developed under operational pressure by one team, refined into a commons contribution, gated through a sanitization pipeline, merged into the base package, and automatically picked up by the stewardship layer that tends the whole ecosystem. No one had to manually propagate the update. No one had to remember to tell the other teams. The infrastructure did it.
Collective Intelligence and the OODA Loop
Alignment is a polycentric engine, to feign otherwise is a short-sighted slight of hand.
OODA — Observe, Orient, Decide, Act — is a framework for operating faster than your adversary's decision cycle. The team that can loop faster wins. But the original formulation assumes a single decision-maker. What happens when the decision-maker is a swarm?
The journalism team's operational tempo was shaped by their agents' ability to loop quickly: observe new information, orient it against existing context (the handoff), decide what matters, act. The handoff skill was their OODA infrastructure — it was what made orientation fast. Without it, every session started at "observe" and had to re-derive "orient" from scratch. With it, a new session could start already oriented and go straight to "decide."
The word "nimble", in NimbleCo, describes a specific commitment: to loop faster than the alternatives via polycentric swarming networks. Not by moving carelessly but by maintaining the context that makes fast decisions safe. The handoff discipline is part of that infrastructure. So is the gardener. So is the sanitization gate. Each piece reduces the friction between "we learned something" and "the whole system benefits from it."
The OODA loop for a multi-agent system isn't just within a single agent's session. It's across sessions, across agents, across teams. The session-handoff skill closing in on the base package is one full loop: a team observed a problem, oriented their tooling, decided on a pattern, acted to generalize it. The next team starts their loop already one step ahead.
Privacy-Preserving Incentivized Collab
The hardest problem in commons contributions is not technical. It is incentive alignment. Why would a team that spent months developing a useful workflow give it away? What do they get back?
The sanitization gate is part of the answer: it makes the contribution safe to give away. The journalism team didn't have to worry about accidentally leaking operational context because the gate would catch it. Their memories are already gitignored. The act of generalizing the skill — stripping the domain specifics — was also the act of ensuring the contribution contained nothing sensitive. The mechanics of the commons contribution are also the privacy guarantee.
But there's a deeper incentive: the base package is what everyone starts from. Contributing to it means your methodology becomes the default. The next team to deploy a Hermes agent starts with the session-handoff discipline already installed. They benefit from work the journalism team did. And when they refine it under their own operational pressure and contribute back, the journalism team benefits from that. The commons compounds.
This is not altruism. It is a different kind of self-interest — one that operates on a longer time horizon and accounts for the value of the network. The team that contributes useful methodology to the base package is also the team that gets every future improvement to that methodology for free. But even more to the point, their advantageous evolutionary mutations being accepted into the borg reduces their own merge-conflict friction on updating from latest.
In the age of agentic AI, this dynamic is new and important. AI agents are not just tools — they are operationalizing their teams' knowledge as colleagues with alien intelligence. When that knowledge is generic enough to be shared, sharing it is a force multiplier that benefits everyone in the network. The sanitization gate makes the sharing safe. The commons makes the sharing worthwhile. The gardener makes the sharing automatic.
The Ostromite commons are well and good BUT also, everyone, from a semi-autonomous venture co-op to an investigative journalist swarm, can still protect the only moat left in the agentic era; lead time. You can choose your own adventure with what and how much to share. You can donate or charge. You can gate or invite. Regardless, the forge glows red-hot.
The Receipt Becomes a Stencil
A receipt records one transaction. The session-handoff skill landing in the base package proved the pattern once — one team, one skill, one clean pass through the gate. Proof is not yet infrastructure. What turns a proof into infrastructure is the moment the shape of the thing can be handed to someone who was never in the room.
So we cut the pattern into a stencil. There is now a template — usecase-package-template, a repository you fork to start your own use-case package with the whole pipeline already wired: the two-layer sanitization gate (a deterministic pass that catches credentials and PII and fails closed, a semantic pass that reads for the particulars of your domain and routes them to a human), the instance overlay that makes your operational data private by construction rather than by discipline, the plugin and skill scaffolding that a Hermes agent already knows how to load, and the contribution paths that let you promote a refined technique into your own package or propose it upward into the commons. You fill in what is yours — the domain noun, the tools, the methodology, the souls. The machinery that separates the shareable from the sovereign is already there.
The separation is the whole game, and it runs in two directions at once. Outward: what your repository shows the world — private by default, per-artifact, flipped to public only when you choose, because lead-time is the last moat the agentic era leaves standing. Inward: what one user of a shared deployment can see of another — skills, working files, and memory scoped to a context rather than bleeding across every chat the agent serves. The first is a question of visibility. The second is a question of containment. The template carries guidance for both, and it is honest about which of its boundaries are real walls and which are defense in depth — an in-process read-deny that a determined same-user terminal can still walk around is not the same as a secret that was never mounted into the agent's namespace at all. Naming that difference is part of the contribution.
And there is a deliberate asymmetry at the top of the funnel. When a contribution is offered to the base package — the substrate every deployed agent inherits — we do not merge the submitted bytes. We close the pull request and rewrite the capability from the described pattern. The credit is yours; the code is ours to author. This is not gatekeeping for its own sake. The base ships to everyone, so an injected line carries the blast radius of the entire fleet, and the only way to keep the commons trustworthy as it opens to contributors we have not yet earned trust with is to treat every inbound artifact as a proposal and never as a merge. The gate makes sharing safe. The rewrite makes accepting it safe. Both have to be true before a commons can hold weight.
The journalism team showed what one loop looks like. The template is what it looks like when the loop becomes something you can pick up and run without us.
Edge intelligence is the product
The session-handoff skill is one data point. The pattern it represents is the interesting bit.
Every team running a custom Hermes deployment (or any homerolled Frankenstein harness) is developing operational knowledge — not just what their agents do, but how they do it, what disciplines make multi-session work tractable, what the failure modes are, how to recover from them. Some of that knowledge is specific to their domain and should stay private. Some of it is genuinely general and belongs in the commons.
The infrastructure now exists to do that safely: fork from the base package, develop under operational pressure, generalize and sanitize, contribute back through the gate. The gardener closes the loop. The base package compounds.
The question for every team running agents is not just "what can our agents do?" It is "what have we learned about how agents work well, and is any of that generic enough to give back?" The answer, more often than people expect, is yes.
NimbleCo is building the infrastructure for that answer to be acted on. The journalism team showed what it looks like in practice. The session-handoff skill in the HSM base package is the receipt.
—
NimbleCo builds open-source infrastructure for agentic AI systems — orchestration, memory, multi-agent coordination. hermes-swarm-map and hermes-agent-mt are available at github.com/NimbleCoAI.
