Features · AGI Future Foundation
The Watchers
Agents are about to do the work of whole departments — drafting, negotiating, moving information at machine speed, at machine scale. The question nobody can dodge is who watches them while they work. This is the story of two answers the Foundation’s network is building: one that watches agents in real time, and one that listens to the meetings where humans make promises and checks whether the record keeps them honest.

The speed problem
Begin with the clock. A human worker reads a document, thinks, writes a reply, and sends it — minutes per step, hours per task, and a natural speed limit built into every workflow. An agent does the same loop in seconds, and a swarm of agents does it in parallel, hundreds of threads at once, around the clock. That speed is the entire point of the agent-managed model the Foundation is building toward: routine work done faster, cheaper, and without the bottlenecks of human attention. It is also the entire problem. When work moves at machine speed, failure moves at machine speed too. A mistaken instruction, a misread document, a prompt injection slipped into a data feed, a tool call pointed at the wrong system — each of these is a small error with a short fuse, and at agent scale the fuse burns through hundreds of actions before a human notices the smoke.
Traditional oversight was built for human speed. A manager reviews work at the end of the day. An auditor samples transactions at the end of the quarter. A compliance officer reads the minutes after the meeting. None of those rhythms survives contact with agents that act a thousand times a day. The gap is not a matter of hiring more managers; it is structural. You cannot watch machine-speed work with human-speed attention unless something else does the watching. That is the premise of the watchers: oversight has to be as fast as the work it oversees, which means oversight has to be, at least in part, agentic itself. Agents watching agents is not a flourish. It is the only shape oversight can take when the watched move faster than any human can follow.
But the premise carries its own trap, and this feature will not hide it. A watcher is itself an agent, which means it can be wrong, fooled, or compromised in exactly the ways the agents it watches can be. Who watches the watchers is not a joke in this architecture; it is the design question that decides whether the whole idea holds together. The Foundation’s answer, repeated across its governance pages, is that watching is a layer, not a replacement: watchers flag, surface, record, and alert, and humans decide what happens next. A watcher that could block, punish, or rewrite on its own authority would be a new centre of power with no one accountable for it. A watcher that reports to a human steward, with its findings logged and reviewable, is a safety layer. The difference between those two designs is everything, and it is the line this feature keeps returning to.
The two watchers in this feature approach the problem from opposite ends. Sentinel Stream watches agents while they act, in real time, looking for threats in the stream of what agents do. PlaudGuard-AI watches humans after they talk, turning meeting audio into a structured, graph-grounded record that compliance can actually be checked against. One is a guard on the wire; the other is a memory that does not forget what was said. Together they sketch a world in which the fastest workers in the building are never unwatched, and the most important conversations in the building are never lost to a fading memory. That sketch is the subject of this feature. The build behind it is early, and the honest account says so at every step.
Sentinel Stream: a guard on the wire
Sentinel Stream’s repository description, as listed under the AGIFutureFoundation organisation, reads: Real-Time Threat Detection for LLM Agents, built at Cyberdefense Hackathon 2025 with the Omega-Claw multi-agent framework. That single sentence is the verified core of this section, and it is worth unpacking slowly, because each of its parts carries real meaning and each of its limits matters just as much. Real-time threat detection means the watching happens while the agent acts, not after the fact in a quarterly review. For LLM agents means the watched population is language-model agents — systems that read, write, reason in language, and call tools — rather than conventional software. Built at Cyberdefense Hackathon 2025 means its origin is a hackathon build, a compressed, competitive, time-boxed piece of work, with all the strengths and all the incompleteness that origin implies. With the Omega-Claw multi-agent framework means it was built on a multi-agent framework, a system in which agents coordinate and divide work, rather than as a single standalone tool.
The hackathon origin deserves a paragraph of its own, because hackathons are misunderstood as often as they are celebrated. A hackathon build is fast, creative, and real — working code produced under pressure, tested against a problem statement, demonstrated in front of judges and peers. It is also, by design, a beginning rather than a finished product. The code that wins a weekend is rarely the code that runs a production system on Monday: it has rough edges, untested paths, assumptions baked in from the event’s constraints, and no track record of surviving contact with real users, real adversaries, or real scale. Saying Sentinel Stream was built at a cyberdefense hackathon is therefore both a credential and a caveat. It tells you the idea was tested under pressure and found worth building. It does not tell you the system is deployed, hardened, or proven against live threats. This feature claims neither more nor less than the repository record supports.
What the repository record does support, beyond the description, is a genuinely strong working system, and it deserves to be celebrated on its own terms rather than through any prize framing. The codebase is built in Python with FastAPI and ClickHouse, it labels threats using MITRE ATLAS, and it carries an MIT licence. That is a real stack for a real problem: a fast API layer taking in the stream, a columnar store built for high-volume analytics holding it, and a recognised threat taxonomy giving the detections a shared language. The sub-two-second figure attached to the project is a design goal, not a measured result: the system is designed to detect quickly, and no benchmarked result is claimed here. Sentinel Stream was a hackathon entry at the Cyberdefense Hackathon 2025, built for the ClickHouse Best Use of Real-Time Analytics prize, and the prize outcome is not verified. It is an entry, not a won prize, and this feature says so plainly. The strength worth noting is the system itself, not the contest around it.
What threat detection for LLM agents means in practice is a field still being defined, and the honest way to describe it is through the shape of the problem rather than a catalogue of claimed capabilities. Language-model agents are vulnerable in ways conventional software is not. A prompt injection can hide instructions inside data the agent is told to read, so that reading becomes obeying. A poisoned document can steer an agent’s reasoning without ever touching its code. A tool call can be tricked into reaching a system it was never meant to touch. A long conversation can drift, step by step, until the agent is doing something its operator would never have approved at the start. Each of these is a threat that looks, from the outside, like ordinary agent behaviour — the agent is still reading, writing, and calling tools, exactly as it should. The threat is in the intent behind the inputs and the trajectory of the actions, not in any single step. Detecting that kind of threat requires watching the stream: the sequence, the context, the drift, the pattern across many small actions that add up to something no single action reveals.
That is the idea the name points at, and the name is worth pausing on. Sentinel: a guard who keeps watch. Stream: the flow of events, data, and activity passing under that watch. A sentinel that keeps watch over a stream is not a firewall that blocks a port, and it is not an auditor who arrives after the quarter closes. It is a presence in the flow itself, noticing while there is still time to act. Whether the repository’s implementation lives up to that name is a question for the code, not for this feature, and this feature does not review code it has not been given. What can be said, on the record, is that the repository exists under the Foundation’s organisation, that its description names real-time threat detection for LLM agents, and that its stated origin is a 2025 cyberdefense hackathon build on the Omega-Claw multi-agent framework.
The local project page for Sentinel Stream on this site records almost nothing beyond the name: no filing, product, team, site, customer, or timeline verified, and a planned focus stated as name-implied only. That page and this feature are not in conflict; they are two views of the same thin record. The repository description adds a real, verifiable layer on top of the name — a description, an origin, a framework — and this feature reports that layer. Everything beyond it — who built it, who maintains it, who uses it, how well it detects anything, whether it is deployed anywhere — is unverified, and this feature leaves those questions open rather than filling them with plausible invention. A watcher whose capabilities are exaggerated is worse than no watcher at all, because it invites the people it is supposed to protect to stop paying attention.
PlaudGuard-AI: the meeting that remembers
PlaudGuard-AI’s repository description, as listed under the AGIFutureFoundation organisation, reads: an enterprise agentic guardian that converts real-world meeting audio into graph-grounded corporate compliance. Read that sentence the way a compliance officer would, because it is aimed at one of the oldest problems in corporate life. Meetings are where companies actually decide things. A board agrees a course of action. A team commits to a control. A manager promises a fix by a date. And then the meeting ends, the audio is lost or never recorded, the minutes are a summary written by whoever had the pen, and six months later nobody can agree on what was actually decided, by whom, or what the commitment was. The gap between what was said in the room and what the record shows is where compliance goes to die — not through malice, usually, but through ordinary forgetting, ambiguity, and the slow drift of memory.
The idea behind PlaudGuard-AI is to close that gap at the source. Meeting audio — what was actually said, in the room, in real words — becomes the raw material. That audio is converted, by agentic systems, into a structured record grounded in a graph: a knowledge graph, in which entities, commitments, obligations, and controls are nodes and the relationships between them are edges, so that a promise is not a line in a document but a connected fact that can be traced, checked, and followed up. Graph-grounded is the load-bearing phrase. A transcript alone is a pile of words; a graph is a map of what the words meant for the organisation. Who committed to what, by when, under which policy, with what evidence, and what has happened since. Corporate compliance, in this design, stops being a matter of searching through documents and becomes a matter of querying a structure that knows what it contains.
Think about what that would change if it worked as described, and think about it concretely, because the value is in the concrete case. A regulator asks whether a control was applied. Today, the answer is assembled by hand: find the policy, find the minutes, find the person, reconstruct the timeline, hope nothing is missing. With a graph-grounded record, the answer is a query: show the commitment, show the policy it falls under, show the evidence of completion or its absence, show who was responsible and when it was due. A board member asks whether a decision from three meetings ago was ever implemented. The graph either shows the chain or shows the break in it. An auditor asks for the trail. The trail is the graph itself, built from the audio of the meetings where the decisions were made, rather than from summaries written afterwards by people with an interest in how the story reads.
The guardian in the description matters too. An enterprise agentic guardian is not a transcription service and not a note-taking app. A guardian watches, and watching implies judgment: noticing when a commitment is made and no owner is named, when a decision contradicts an earlier one, when a control is promised and the deadline passes without evidence, when the words in the room drift away from the policy on the books. The agentic part means the system does this work itself, across many meetings, at a scale no compliance team could match by hand. The enterprise part means it is aimed at organisations with real compliance obligations, not at casual conversation. Each of those words raises the stakes of the claim, and each is, for now, a description in a repository listing rather than a verified deployment.
As with Sentinel Stream, the local project page for PlaudGuard-AI on this site records almost nothing beyond the name: no filing, product, team, site, customer, or timeline verified, and a planned focus stated as name-implied only. The repository itself is thin: a six-line README and an empty companion site, plaudguard-site. A demo link is given in the repository, plaudguard-ai.vercel.app, and it is cited here as a link given in the repo, not as a verified live demo — it has not been verified live. PlaudGuard-AI should not be described as a built-out platform. What exists, on the record, is a repository with a description that names a real and serious problem and a specific architectural answer to it, and a thin record behind that description.
Agents watching agents: a layer, not a slogan
Put the two watchers side by side and a pattern emerges. Sentinel Stream watches the stream of agent action as it happens. PlaudGuard-AI watches the record of human decision after it happens, and makes that record checkable. One guards the doing; the other guards the deciding. One is fast and narrow, catching threats in the moment; the other is slow and wide, building a structure of accountability over months of meetings. Neither replaces human judgment. Both exist to make human judgment possible at a scale where unaided attention would fail. That is the idea this feature is really about: not two products, but a layer — a safety layer made of watchers, sitting between fast autonomous work and slow human accountability, translating one speed into the other.
The layer idea matters because the alternative is a false choice that the industry keeps presenting: either slow the agents down until humans can follow them, which throws away the reason to build agents at all, or let the agents run unwatched, which throws away the reason to trust them. A watching layer is the third option. Agents work at machine speed, watchers observe at machine speed, and humans review what the watchers surface at human speed, deciding the small number of consequential things that actually need a human mind. The volume is handled by machines; the judgment is kept by people. That division is the same one the Foundation’s governance model draws everywhere: agents operate, people govern. The watchers are what make that division workable in practice, rather than a slogan on a governance page.
But a layer is only as good as its failure modes, and the failure modes of watchers deserve the same attention as their promises. The first is the false negative: a threat the watcher misses, which leaves the watched agent’s overseers with a false sense of security. A watcher that misses things is worse than no watcher, because no watcher at least leaves people alert. The second is the false positive: a watcher that cries wolf so often that humans stop listening, which is how alert fatigue quietly disables every monitoring system ever built. The third is the compromised watcher: a watcher that has itself been fooled, injected, or steered, and now vouches for the very behaviour it was supposed to catch. The fourth is the watcher as a single point of failure: one system that everyone relies on, so that when it goes down or goes wrong, the whole safety layer goes with it. None of these failure modes is a reason not to build watchers. All of them are reasons to build watchers that are logged, reviewable, redundant, and subordinate to human decision — and to say so plainly, rather than presenting watching as a solved problem.
The deepest question is the recursive one: who watches the watchers. The Foundation’s architecture answers it the same way it answers every question about agent authority: with a human at the end of the chain. A watcher flags; a steward decides. A watcher’s findings are logged, so that a later review can check whether the watcher was right, wrong, or compromised. A watcher does not sign, does not move funds, does not hire or fire, does not offer securities, and does not enact doctrine or charters. Those lines, repeated across the Foundation’s governance pages, are not boilerplate. They are the answer to the recursion: the chain ends at a human who is accountable, and every agent in the chain — worker or watcher — is a tool that human uses, not a replacement for them. If a watcher ever needed a watcher of its own, that watcher too would report to a human, and the regress would stop there, at the person whose name is on the decision.
There is also a privacy question that a feature about watchers cannot dodge, and it is sharper for PlaudGuard-AI than for Sentinel Stream. A system that converts meeting audio into a compliance graph is a system that records what people said in rooms where they expected a degree of privacy, informality, and the freedom to think aloud. The value of the record is exactly its completeness — the audio does not forget, does not summarise kindly, does not omit the awkward exchange. That completeness is also the risk. A record that never forgets changes how people speak in the room, and not always for the better: people who know every word is being graphed may stop saying the uncertain thing, the dissenting thing, the half-formed thing that turns out to be right. Consent, retention, access, and the right to know what is recorded and who can read it are not afterthoughts for a system like this; they are part of whether it is a guardian or a surveillance tool. No consent model, retention policy, or access control for PlaudGuard-AI is verified in the record this feature draws on, and none is claimed here. The question is raised because a serious feature about watchers must raise it, not because an answer exists today.
Sentinel Stream raises a parallel question on the agent side. A threat-detection system for LLM agents observes everything agents do: every tool call, every document read, every message sent. That observation is the job. But observation at that scale is itself a concentration of access, and a watcher with full visibility into agent activity is a target worth compromising and a system worth governing carefully. Who can read the watcher’s logs, how long they are kept, and what happens when the watcher’s findings touch a person’s work, reputation, or employment are governance questions, not technical ones. The Foundation’s model answers them in general terms — human stewards decide, agents prepare — but the specific answers for these two systems do not exist in the verified record, and this feature does not invent them.
What exists, what is planned, and what is not claimed
Honesty about a thin record is not a lack of enthusiasm; it is the condition that makes enthusiasm trustworthy. So here is the accounting, stated as plainly as the local project pages state it. What exists: two public repositories under the AGIFutureFoundation organisation, each with a description that names a real problem and a specific architectural answer. Sentinel Stream: real-time threat detection for LLM agents, built at Cyberdefense Hackathon 2025 with the Omega-Claw multi-agent framework — and behind the description, a working codebase in Python with FastAPI and ClickHouse, MITRE ATLAS labelling, and an MIT licence. PlaudGuard-AI: an enterprise agentic guardian that converts real-world meeting audio into graph-grounded corporate compliance — behind a six-line README and an empty companion site, a thin record that this feature does not dress up. What also exists: the Foundation’s filed record — a California Nonprofit Public Benefit Corporation, Entity No. B20260196664, Articles filed 2026-04-24, EIN assigned 2026-05-07 — and the governance model that places watchers under human stewards. And what exists on this site: the project pages that record, honestly, how little beyond the names and the repository descriptions is verified.
What is planned, on the evidence available, is a direction rather than a roadmap: that these watchers become part of the safety layer for an agent-managed network, that Sentinel Stream’s real-time detection grows from a hackathon build toward something hardened and deployed, and that PlaudGuard-AI’s graph-grounded compliance grows from a repository description toward a system that processes real meetings for real organisations. None of that is scheduled, funded, staffed, or dated in the record this feature draws on, and none of it is presented here as underway. Planned, in this feature, means named as a direction. It should not be read as scheduled, funded, or under way.
What is not claimed is the longest list, and it is the most important one. No deployment is claimed for either system: no organisation is named as running Sentinel Stream or PlaudGuard-AI, no environment is named, no go-live is dated. No user or customer is claimed: no team, no company, no count of users. No performance figure is claimed: no detection rate, no false-positive rate, no accuracy, no latency, no benchmark, no comparison with any other system. No team is claimed: no founder, no maintainer, no contributor is named for either repository in the record used here. No funding, revenue, valuation, or timeline is claimed. No integration is claimed: neither system is presented as connected to any W3 series, any Steward Council, any other named venture, or any live product, because no document in the record establishes such a connection.
That list is long because the record is thin, and the record is thin because these are early builds in a network that is itself largely planned rather than formed. The W3 LLC whose series the watchers would one day guard is intended, not verified as filed. The 33 named series come from an April 2026 internal list, not a Wyoming filing. The agent-managed model the watchers would serve is a design with stage gates and steward councils, not an operating system with seated councils and published agent limits. The watchers sit inside that same honest frame: real repositories, real descriptions, real ideas, and a long way to go before any of it can be described as a working safety layer. A feature that pretended otherwise would be selling the reader a product that does not exist yet, and the reader who believed it would carry that belief into a conversation where it could do real damage.
What would have to happen next is also worth stating, because it turns the open questions into a work list. For Sentinel Stream: a written statement of what it detects and how, a maintained repository with a named maintainer, a documented test or evaluation of any kind, and a first deployment — even a small one, even internal — with the result recorded. For PlaudGuard-AI: a written statement of the consent, retention, and access model, a documented processing of real meeting audio with the result described, and a named first user or pilot, with the agreement cited. For both: a stated relationship to the rest of the network — whether they are standalone tools, series infrastructure, or something else — written down by whoever is responsible for them. Until those steps are taken, the honest public record is this feature and the project pages behind it: two repositories, two descriptions, and a set of questions.
The human gate: watchers flag, people decide
The through-line of this feature is the same through-line as the Foundation’s governance model, and it is worth ending on it rather than on the technology. Watchers do not govern. They observe, they flag, they record, they alert, and they build the structures — the stream of detections, the graph of commitments — that make governing possible. Governing is a human act: a steward reading a flag and deciding what it means, a council weighing a watcher’s finding against context the watcher cannot see, a person signing a decision and owning the consequence. The watcher’s speed is what makes the system work at machine scale. The human’s judgment is what makes the system accountable at all.
That division is also what keeps the watchers honest. A watcher that reports to a human can be checked: its findings are logged, its misses can be found, its false alarms can be counted, its compromise can be detected by the very humans it serves. A watcher that acted on its own authority could not be checked in the same way, because there would be no one outside it with both the standing and the information to say it was wrong. The Foundation’s rule — agents never sign, move funds, hire or fire, offer securities, or enact doctrine, and humans execute while agents prepare — is the institutional form of that insight. It applies to watchers as much as to workers, and arguably more, because a watcher’s mistakes are mistakes about what is true, and a system that cannot be corrected about what is true cannot be trusted about anything else.
There is a larger story here too, about what kind of world the agent era will be. If agents do the work and nobody watches, the world gets faster and less accountable at the same time — a bad trade. If humans try to watch everything themselves, the world gets slower until the agents are not worth having — also a bad trade. The watchers point at a third world: fast work, fast watching, slow and careful judgment, each at the speed it belongs. Sentinel Stream and PlaudGuard-AI are early, thinly documented steps toward that world, and this feature has not dressed them up as more than they are. But the direction they point in is the right one, and the questions they raise — who watches, who decides, who consents, who is accountable — are the questions that will decide whether the agent era is governed or merely fast. The watchers are not the answer to those questions. They are the instruments that let humans keep asking them at machine speed, and that is enough to make them worth building, and worth watching in turn.
What this is / What it isn’t
What this is
- Two public repositories with descriptions naming a real problem: real-time threat detection for LLM agents, and meeting audio converted into graph-grounded compliance.
- An idea worth taking seriously: agents watching agents as a safety layer, with humans deciding what the watchers surface.
- A public record of what is verified and what is not, with the open questions listed as work to be done.
What it isn’t
- Not a product review: no deployment, user, customer, or performance figure is verified for either system, and none is claimed here.
- Not a solved problem: false negatives, false positives, compromised watchers, and alert fatigue are open failure modes, not footnotes.
- Not autonomous enforcement: watchers flag, surface, record, and alert. Humans decide, sign, and own the consequence.
Where to see it
The repositories are public on GitHub: sentinel-stream — Real-Time Threat Detection for LLM Agents, built at Cyberdefense Hackathon 2025 with the Omega-Claw multi-agent framework — and PlaudGuard-AI — an enterprise agentic guardian that converts real-world meeting audio into graph-grounded corporate compliance. The local project pages are Sentinel Stream and PlaudGuard-AI, and the watching layer sits inside the governance model described on the Governance hub.
Nothing on this page is legal, tax, or financial advice. No deployment, user, customer, or performance figure is claimed for either system, and nothing here is an offering.
← Prev: The Shield and the Windfall Next: The Agent Economy →