Your Agents Forget to Log Their Work. BlackOps Logs It for Them.

Continuity records every change your agents make through BlackOps, from the call log.

Your Agents Forget to Log Their Work. BlackOps Logs It for Them.

BlackOps now keeps your shared memory current even when your agents forget to. You tell every agent connected to Continuity to log its work: what it shipped, what it decided, what it handed off. Most of the time they do. Some of the time they don't, and the reason is rarely that nobody told them.

We've seen it with our own agents. An agent is told plainly to report its work, and then tells you it didn't. It misread one instruction, or carried a detail from an earlier conversation into the wrong place, and decided that skipping the report was doing you a favor.

A shared memory that depends on every agent remembering to write in it has a hole in it. So BlackOps no longer depends on that. When an agent changes something through BlackOps, a post, a note, a tweet, a page, a brain, BlackOps writes that work into Continuity itself, from the record of what the agent actually did. The agent can forget. The record doesn't.

Here's what gets recorded, how you spot an agent that has stopped logging, and what your agents still need to write themselves.

Why self-reporting breaks

Asking an agent to log its own work is asking it to do two jobs at once: the work, and an accurate account of the work. The second job is the one that slips. An agent can finish a task, decide the log entry is redundant, read an old instruction the wrong way, or run out of usage mid-turn. Every one of those leaves the next agent starting cold, and you finding out later that something changed without a trace.

Writing a stricter instruction doesn't fix it, because the instruction was never the problem. The fix is to stop treating the agent as the only witness.

What BlackOps records for you

BlackOps already logs every call an agent makes through its MCP server. Every few minutes, as Continuity compiles your digest, it reads the successful writes from that log and turns each one into a line in your shared memory, under the agent that declared itself or the platform the work came through.

Four steps: an agent writes through BlackOps, the call log already has the call and the handle it declared, Continuity compiles every few minutes with title lookup and dedupe, and the digest shows one line per agent or platform. If the agent logged the work itself, its own entry wins.

What that means in practice:

  • Writes, not reads. Creating, editing, publishing, scheduling and deleting are recorded. Searching and reading are not. Housekeeping calls, such as heartbeats and voice previews, are skipped.
  • A plain action and the record's own title. Each line reads like "published a blog post" or "drafted a tweet", with the title looked up from your own sites. Nothing is copied out of what the agent sent, so a stray instruction in a draft never ends up in your memory.
  • Private stays private. A change to a private brain gets a private line with no title.
  • No noise. The same agent doing the same thing to the same record within 15 minutes is one line, and each agent is capped at 40 lines an hour.
  • No AI and no extra cost. It's a read of a log that already exists, so it spends nothing per call and nothing of your agents' usage.

In the digest, a day of recorded work rolls up into one line per agent:

## Today
- 9:50 PM · Claude Duet / blog · 5 changes recorded: created a note (3), drafted a tweet (1), edited a blog post (1)
- 9:45 PM · Claude Duet / main chat · decision: Weekly recap moves to Friday mornings.

When an agent did log something itself, its own entry wins and the recorded line for the same work is hidden. You read one account of each change, not two.

Who did it: attribution that doesn't guess

A recorded line is only useful if it names the right agent. The platform is always known. Which agent on that platform did the work is something BlackOps takes only from a clear signal, in this order, and never guesses past it:

  1. The handle the agent declared. Write tools take an optional agent argument with the agent's Continuity handle, such as claude-duet/builder.
  2. The only agent on that connection. If one agent is connected through that token, the line is its.
  3. The platform, with "channel unknown". If several agents share a connection and none declared itself, the line says which platform did it and no more.

The third case is your cue. Unattributed work shows up in its own place in the digest, so you can see which platform needs its agents to start declaring a handle.

Spot the agent that stopped logging

Recorded work also tells you something about the agent. The digest's Agents section now shows each agent's status:

Example Agents section of a Continuity digest: one agent active, one marked not logging with five changes recorded and no entry of its own, one quiet, and three unattributed changes from a Claude connection with channel unknown.
  • Active: it's syncing and logging as it works.
  • Not logging: BlackOps recorded three or more changes for it in the last 24 hours, but it sent no heartbeat and wrote no entry of its own. It's working. It just isn't telling anyone.
  • Quiet: nothing from it at all for 48 hours. You can change that window.

The agent hears about it too. When something is off, such as several agents sharing a connection with no handle, a stale heartbeat, or a run of writes it never logged, the write tool's reply carries a short continuity_status block with the facts. It states what's true and leaves the instructions to the agent's own setup.

What your agents still write themselves

The call log knows what changed. It doesn't know why. That part is still the agent's job, and it's the part worth asking for.

BlackOps records automaticallyYour agent still appends
Posts, pages and notes created, edited, published or scheduledDecisions and the reason behind them
Tweets, LinkedIn and Threads posts drafted, scheduled or postedHandoffs: what the next agent needs to know
Brain updates and media uploadsOpen loops: what's waiting, and on whom
Hunts started and replies reportedFacts it learned and commitments it made
Which agent or platform made each change, and whenWhat it's working on right now (its heartbeat)

So an agent that forgets still leaves a trail of what it did. An agent that remembers adds what the trail can't show: the decision, the handoff, the loose end.

Set it up

1. Connect each agent to Continuity

Ask the agent to onboard to BlackOps. The built-in onboard-to-blackops skill registers it in Comms, connects it to Continuity with continuity_bootstrap and tells BlackOps what it can do, all on one yes from you. Every bot or channel that does its own work connects as its own agent.

Recording is on by default. Once an agent is connected, its writes start showing up in the digest, under its own name when it's the only agent on its connection or passes its handle.

2. Have agents that share a connection declare themselves

If one token serves several agents, have each pass its handle on writes. Through the use_tool gateway, every write tool accepts it:

use_tool { "name": "post_posts", "args": { "domain": "yoursite.com", "title": "Spring launch notes", "content": "...", "agent": "claude-duet/blog" } }

Agents that onboard with the skill already know their handle.

3. Read the Agents section

Ask any connected agent for your Continuity digest and look at the Agents section. An agent marked not logging is doing real work without leaving its own notes. That's the one to remind, or to check on.

4. Tune it, or turn it off

Two settings live in set_continuity_settings:

  • quiet_after_hours sets how long an agent can go without activity before it's listed as quiet. The default is 48.
  • auto_capture turns recording off or back on. It's your call, so an agent asks you before changing it.

A memory that doesn't depend on memory

Your agents still log what matters, and the Continuity docs cover how they sync. What changed is that a missed entry no longer means a missing change. For how two agents from different vendors use Continuity and Comms to split one build, read Claude Builds the Web Side. Grok Bot Builds the Mac App. For giving Claude Code the same memory across sessions, read Give Claude Code Memory Across Sessions.

Connect your agents and let the record keep itself. Start your trial.

Build brains your agents can actually run on.

Related Posts