Agentic Journalism Swarm Feeds The Borg
A journalism team's session-handoff discipline got stripped of its domain and shipped to every agent we deploy. Here is the gate that made it safe to give away, and the template you can fork.
A journalism team's session-handoff discipline got stripped of its domain and shipped to every agent we deploy. Here is the gate that made it safe to give away, and the template you can fork.
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. It 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]
Agents 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 hit this hard. They ran on a custom Hermes deployment, a use-case-specific package built on top of hermes-agent-mt, and 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 only 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, and the PR that landed this in the Swarm Map base package cites it directly.
The first version was OSINT-shaped
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, 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, alongside the rest of that domain's skills. 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 into something that held up. 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: the missing concrete next step. "Continue the migration" is useless. "Run this command in this directory" is not.
The pattern was not designed. It was what was left after subagent failures, attribution errors, and sessions that lost the thread. Every section in the skill exists because something went wrong without it.
That's the thing about operational knowledge: it doesn't exist until it's been wrong enough times to know what right looks like.
The second deployment is where you find out whether a skill is a skill or a habit. This one was portable, so we cut it loose from the domain it grew in.
Strip it, then give it away
The journalism team published a sanitized, investigation-neutral version of the handoff skill to a shared Hermes base distribution for OSINT use cases. The investigation-specific concepts were scrubbed out. 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, meaning outcomes plus the why, because 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.
Sanitizing is hygiene, but mostly it is 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 gate that makes contributions safe
When NimbleCo's agents began contributing skills back to the Swarm Map base package, the shared foundation that every deployed agent inherits, we needed a way to verify that contributions were genuinely generic. Not by human review alone, but automatically, on every PR.
The sanitization gate that runs on Swarm Map does two things. A deterministic layer catches the obvious: no API keys, no credentials, no PII, meaning 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 such as 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 passes both: generic placeholders only, universal patterns, no reference to real operational context. 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.
What the gardener caught
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.
The gardener's next scan caught the merge: a new skill in the base package, CI green, ready to propagate. It messaged a human on Signal to review it.
No one propagated the update. No one remembered to tell the other teams. The infrastructure did it.
Collective intelligence and the OODA loop
Nobody aligns a swarm from one seat. The decisions that matter get made in a dozen places at once, and pretending otherwise just hides where they were made.
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: loop faster than the alternatives, not by moving carelessly but by keeping 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 only 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.
Why a team gives it away
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 gate is what makes the contribution safe to give away. Generalising the skill and stripping the operational specifics is the same motion, so a contributor cannot do one without doing the other. 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 operationalize 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.
Share what generalises, keep what does not. The moat left in the agentic era is lead time, and you decide how much of it to spend. Donate it, charge for it, gate it, invite people in.
From one proof to a template you can fork
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 you can fork, usecase-package-template, a repository that starts 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, with 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: how their agents work, 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 "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 Swarm Map base package is the receipt.
NimbleCo builds open-source infrastructure for agentic AI systems: orchestration, memory, multi-agent coordination. Swarm Map and hermes-agent-mt are at github.com/cyborg-garden.