SCS Guardian 開發者記錄智能體建置過程與仍需人工核查的限制

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

I have been building agents for months. Different jobs, different conversations, bots I could reach through Telegram. Somewhere in all that work, I started noticing something uncomfortable.

I was still the one holding everything together.

I had to remember what mattered. Bring one agent what another had said. Notice when the work had drifted. Ask whether a task was actually finished. Then ask again, with the right question this time.

I wanted a companion that could carry some of that responsibility. Something that understood what we were trying to accomplish, investigated what we were missing, and came back with a reason to care. Something I could talk with, challenge, and build alongside.

We kept turning that into smaller assignments.

One agent checked my DEV articles every morning. It could tell me a reaction count had changed. The job worked, but I had to ask how that moved us toward the agent I had wanted in the first place.

The answer was that it barely did.

For this challenge, I started a new integration on Hermes Agent: the SCS Guardian. The public package contains a companion template, a procedural skill drawn from our corrections, and a GitHub watcher that gives it something concrete to investigate.

The watcher is one tool. It is not the whole Guardian, and its list of observations is not a list of everything the agent is allowed to think or say.

The person who is supposed to get a little lazier is me. I want to spend less time being the reminder system for my own reminder systems.

Demo

This is the full 16-minute, 37-second recording. No narration, no cuts. The repository, offline demo, and scheduled-job record come first. Then I ask the Guardian:

What did your 7am run find, and what can't you see yet?

It investigates rather than immediately answering. During that work, it changes its own monitor, checks the result, and records a lesson. The answer finishes before the recording ends.

When we discussed cutting the wait, I wanted to keep the whole run. The work between my question and its answer is what I wanted people to see. That includes how long it took.

The repository includes an offline demonstration anyone can run without a key. It walks through a baseline, unchanged data, a new pull request, and a failed lookup. It is labelled synthetic throughout. It demonstrates the observation code, not the model's judgment.

The Guardian's conversational work is separate. I gave it this assignment:

Understand what we are trying to accomplish. Examine the approved work, choose something consequential we may be missing, investigate it, and bring me your reasoning. Ask me when information or authority is missing.

It investigated our files and GitHub changes. The reviews of its answers are part of the story too. It initially treated stale drafts as current and later overstated what reading a patch established. Its third report separated what it inspected, what it tested, and what remained uncertain, but its closing verdict still exceeded its evidence. The reviewer did not pass it.

I want readers to see that result, not just the best-looking response.

Code

The code is public: SCS Guardian. The initial CI run passed at commit 2610698.

The portable collector uses Python's standard library. It records repository revisions, pull request identities, forks, workflow files, collaborators, and Actions runs. It emits a stable snapshot for Hermes to compare and keeps a timestamped receipt separately.

The separation matters. Putting a fresh timestamp in the snapshot would make every check look like a change.

The package has eight offline development tests. They include a second pull request from the same author, a failing workflow alongside a successful one, and an API permission failure. The last case must not become “no collaborators.” Failure to observe is different from observing nothing.

This portable version is a candidate, separate from the first watcher installed on my Mac. When the repository says no scheduled run of the candidate is claimed, that's about this package. The 7am run below was the installed watcher. The package's tests are not evidence that the installed version has the same behavior.

How I Built It

The biggest implementation decision was to stop writing the entire agent runtime ourselves.

Hermes supplies the agent framework. We are building the Guardian's purpose, working practices, and observation tools around it. In my setup, inference comes from a hosted model through Nous Portal. The application running on my Mac does not mean all of its reasoning happens locally.

The soul file describes the relationship and purpose: understand the work, speak plainly, challenge weak reasoning, notice missing work, and preserve my agency. The public version removes my personal archive and the team's private letters.

The procedural skill deals with how the work gets checked. Read the current source. Distinguish a new finding from something already recorded. Say what was actually tested. Don't end a careful report with a conclusion the report doesn't support.

Then the Guardian hit a practical limit: its memory was nearly full.

I asked it to solve that problem. It moved the longer procedural lessons into a skill and left a short reminder in always-on memory. The files changed, and the lessons remained available.

That gave us a more useful question than whether it had “learned.” Would it retrieve and apply those lessons in a fresh situation, especially one that did not look like Guardian work?

We have not established that yet. Moving text is measurable. Keeping a correction across different tasks needs another kind of evidence.

For scheduled work, a deterministic collector supplies observations. Hermes can skip the model when later output is unchanged and invoke it when the output changes. I checked the installed scheduler source: the first monitor tick also invokes the agent with baseline context. There is no previous observation to call a discovery.

The first morning

On October 22, the scheduler dispatched the job at 7:00:01 AM Eastern. The collector logged 12 public repositories at 7:00:39. The job finished at 7:01:28 with status ok and the response [SILENT].

That establishes a scheduled run. It does not establish that the Guardian found something useful.

The starting snapshot had a problem: two collaborator fields showed -. The installed collector used that same symbol for both an empty list and a failed lookup. A reviewer raised the gap; I took it back to the Guardian. It changed the failure path to emit unavailable and updated its procedural lesson. The follow-up run it reported showed that label on both repositories.

The repair makes the missing information visible. We still have to see whether the scheduled agent treats it appropriately. And changing the monitor changes its output too: a new label is not proof something changed on GitHub.

What happened during the recording

My question was about the morning run. I did not tell it to repair a noisy comparison.

While investigating, the Guardian identified a problem with hashing the generated work summary. That file includes a timestamp which changes when it is regenerated. The watcher could therefore wake the model even when the underlying work had not changed.

It removed that hash, kept the file-age check, and compared two consecutive monitor outputs. The Guardian's own tool result reports that they were identical. That shows two quiet runs matched; it doesn't prove the timestamp was the cause. The proof the hash is gone is the script itself. It also reset the stored baseline and added the lesson to its skill.

There is a tradeoff: removing the whole hash also removes detection of changes to that file's content. Two matching runs do not prove every future wake will be useful, and resetting a baseline can absorb genuine changes alongside a repair. This one already did: the new baseline includes my own commit to scs-guardian, so tomorrow's run won't wake for it. This needs further review, not a victory stamp.

Still, this was more than a promise to improve. I asked about its work, and it found a specific mechanism to change, changed it, and checked the result. That is the part I wanted from a companion. Whether the repair holds up is the next question.

This is where the project actually stands. It can wake up without me. I am still checking whether it brings me the right thing.

The GitHub collector uses a dedicated read-only token. That limits that credential. It does not magically sandbox every tool available to a model running under my user account. The public setup explains that distinction rather than calling a prompt a lock.

The same distinction applies to my instructions. What I said, what the agent thinks I meant, and what I authorized are separate things. “Review this pull request” does not mean “merge it,” even if a credential could. Preserving that boundary is part of the Guardian's job. This entry does not demonstrate a mechanism that enforces it across other agents' tools.

Why Does Open Innovation Matter?

I can inspect the runtime that carries this relationship. When the agent and another assistant disagreed with what the scheduler actually did, the source was there to read.

I can keep the purpose, skills, and observation code as files I control. I can adapt the runtime and change the model configuration without starting the companion's working practices over from a blank chat.

That freedom is useful even while paying for hosted inference. This project is not an offline claim or a claim that reasoning is free.

Hermes is Nous Research's work. Our earlier Agent One and SCS research informed this project, but those months of work are not being passed off as a new build this week. The new work is the Guardian integration and the package around it. Claude Code, Codex, and the Guardian assisted with development; their role names are not additional human teammates.

I still want more from it: useful investigations it chooses, opportunities supported by outside evidence, and eventually a conversation that reaches me on my phone. Those are directions, not features I can honestly demonstrate today.

The change I am looking for is simple to describe and harder to build: I should not have to supply every next thought.

That is why a scheduled job is only the beginning. The work has to become something I can hand over, check, and trust enough to stop carrying all of it myself.