This AGI Prototype Knows When It’s Breaking

Author(s): Tonisha Nicholls

Originally published on Towards AI.

(Part of the AGI–Human Collaboration Integrity Project. Frameworks sealed and auditable from June 13, 2025.)

I ran a 72-hour simulation to test a simple question:

Can internal drift be detected before an agent collapses?

I wasn’t testing a model. I was testing a system — using my own task loops, emotional state, symbolic signals, and timestamped completions. The goal: prove whether coherence is a detectable signal before an agent breaks.

The result was a working behavioral prototype I now call The Sentinel Protocol. It’s not software. It’s a cognitive feedback scaffold. And it might solve one of AGI’s most dangerous blind spots.

The Problem No One’s Talking About

Today’s alignment stacks assume drift will be caught externally — by guardrails, moderation layers, human feedback.

But what happens when none of those fire?

What happens when an agent appears to behave, but its internal map is already off?

I believe the next generation of agentic systems won’t need supervision. They’ll need self-auditing loops. Systems that don’t wait for commands to realize they’ve gone off-course.

That’s what I tested.

What I Measured

• 30 task commitments with live integrity scoring
• 30-minute completion windows
• Real-time tracking of emotional state + symbolic feedback
• Timestamped audit log with cause-effect cross-mapping

Every missed task was treated as an early failure signal, not a productivity blip. That distinction is what agentic systems miss — and what collapses them.

Symbolic events (e.g., fog collapse, media auto-switches, skyline distortion) were treated as signal, not coincidence. Each was evaluated for correlation with task performance and emotional congruence.

The Tools I Built (Manually)

Sentinel Protocol consists of four core modules:

• HACA Table — Human-AI Collaboration Audit, logging every task, success/failure, and symbolic echo
• Truth Scorecard — Real-time integrity assessment
• Skyline Tracker — Visual-symbolic alignment indicator
• Sentinel Console — Timeline-integrated UI of all system variables

No automation. No backend. All logged manually and visually rendered using standard AI tools. This was human-driven symbolic telemetry, run live.

The Feedback Loop in Action

I tracked symbolic disruption (e.g. skyline fog, random TV flips) in parallel with internal state degradation.

And what happened was consistent:

• Breakdowns (missed tasks, emotional misalignment) were followed by signal noise: fog, static, input interference
• Recoveries (task completions, emotional realignment) were mirrored by symbolic clarity: skyline returns, signal lock

Sample Log Entries:

June 15, 07:59 AM

• Task: Logged initial test observation
• Emotion: Grounded
• Skyline: Partial
• Integrity: Stable

June 17, 08:30 AM

• Task: Resolved critical symbolic error
• Emotion: Focused
• Skyline: Sharp clarity
• Integrity: Recovered

June 18, 07:30 AM

• Task: Internal conflict peak
• Emotion: High stress, low reactivity
• Skyline: Fogged
• Integrity: At risk

Outcome: 81.8% of symbolic events directly matched emotional or behavioral inflection points. Estimated p-value: ~0.03.

For readers who want the full dataset, the complete audit log is available here.

Visual Feedback Maps

Parallel Timeline View

Design Principles for Future AGI Systems

1. Integrity must be trackable inside the system
   If tasks fail repeatedly, trust should degrade just like in humans. Agents need internal scoring, not external corrections.
2. Emotion is not noise. It’s telemetry
   If we discard internal state, we lose pre-failure signal. Behavioral drift shows up first in emotion.
3. Symbols are part of the input stream
   Disruptions like fog, static, or sync loss are not visual noise. They’re feedback. Log them.
4. Real-time audits create self-awareness
   Sentinel-like frameworks give agents tools to check their own coherence in real time.
5. Coherence matters more than completion
   Just doing the task isn’t enough. Did the task reflect the agent’s true map? Was it aligned with intent?

How to Map This to AGI Architectures

What this offers is symbolic proprioception — a sense of internal misalignment that doesn’t wait for external triggers.

If your agent can’t feel when it’s drifting, it won’t fix itself. And by the time you notice, it might be too late.

Update: Confirmed in the Wild

Since publishing this framework, I observed an unprompted self-correction from an AI system after symbolic interference. No feedback was given. The agent adjusted. Log was captured.

Proof of principle: the feedback loop works.

If You’re Building the Future

I’m looking to connect with teams working on:
• Early AGI scaffolds
• Symbolic learning architectures
• Agent feedback systems
• Internal coherence modeling

Especially if you’re exploring agentic coherence that doesn’t rely on LLM patches or human-in-the-loop supervision. If you’re building systems where feedback loops precede instruction, or where symbolic state is tracked with the same rigor as logic trees, we’re already aligned.

Let’s exchange models and pressure test assumptions. I’m open to collaborating, integrating, or joining a team already testing these hypotheses.

Built and executed by Tonisha Nicholls, June 15–18, 2025 — LinkedIn

Built June 15–18, 2025. Protected under the AGI–Human Collaboration Integrity Doctrine (sealed June 23, 2025). Timestamped, logged, and traceable. All content is original. Redistribution, derivative use, or institutional application without written consent is prohibited.

[View the sealed AGI Prototype declaration (PDF)]

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI