As the one who’s supposed to keep things running long term, I’m not sure if this is just normal and harmless, or if it's gonna hurt us later.
If you’ve been in this situation: should we just accept it? If not, when does it start causing real problems?
I’m a software engineer and I’ve been building agentic workflows lately. Like many of you, I got concerned about giving LLMs "write access" to tools. Whether it's a payment API, a database deletion, or a simple email send, the risk of a hallucination causing a $5k mistake is real.
I wanted a way to keep a human in the loop without rewriting my entire agent logic every time. So I built Sentinel.
It’s a lightweight Python layer that wraps any tool/function. The key principles I focused on:
Fail-secure by default: If the rules engine or the network fails, the action is blocked. Most systems fail-open, which is a nightmare for security.
Zero-trust Decorator: You just add @protect to your functions. It’s agnostic to the framework (works with LangChain, CrewAI, or raw OpenAI calls).
Semantic Anomaly Detection: Beyond static JSON rules (like "max $100"), it uses a Z-score analysis of historical audit logs to flag unusual behavior—like an agent suddenly trying to call a function 100 times in a minute.
Context-Aware Approvals: The approver sees exactly what the AI saw (the state before the action) to make an informed decision.
It’s open source (MIT) and just launched on PyPI: pip install agentic-sentinel
I’d love to hear your thoughts on the "Fail-secure" approach and how you guys are currently handling AI tool governance in production. I'm here to answer any questions!
This is part of our SIGMA Runtime project — a cognitive control layer that runs on top of any LLM and tracks drift, coherence, and identity persistence in real time.
---
Why we did this
Most LLM evals measure short reasoning spans — 1-10 turns. But when a model is asked to sustain a line of reasoning over hundreds of steps, subtle feedback effects appear:
- Semantic drift: meaning slowly shifts as text compounds. - Crystallization: the model locks into repeating its own phrasing or style. - Identity loss: the “speaker” loses internal consistency.
We wanted to see whether it’s possible to prevent these effects at runtime, without retraining or prompt resets.
---
What’s new here
We replaced the older ACE anti-crystallization layer with a new system called AEP (Adaptive Entropy Protocol) — a real-time regulator that injects controlled entropy into model outputs.
AEP tracks three internal metrics: - TI — Terminological Isometry (consistency of key concepts) - SDC — Semantic Drift Coefficient (meaning variation rate) - L/N — Logic-to-Noise ratio (logical density vs surface variation)
When the model becomes too stable (repetition, rigid phrasing), AEP adds micro-perturbations to restore variation. When it drifts too far, it dampens entropy back into equilibrium.
---
How we tested it
- 500 reasoning cycles per model (OpenAI GPT-5.2 & Gemini-3-Flash Preview) - Every 50th cycle = a Rib Point that compresses and verifies the last 49 steps - Continuous telemetry from the runtime (coherence, drift, entropy) - Identity: same synthetic agent (“LEO”, AI architect/cognitive scientist)
---
What happened
Both models completed all 500 cycles without identity loss or semantic collapse. Entropy modulation increased lexical variety, while keeping reasoning trajectories coherent.
When truncations occurred (Gemini API), the runtime reconstructed missing context using prior compression checkpoints.
---
Visual results
Drift & coherence evolution (500 cycles) GPT-5.2: https://files.sigmastratum.net/Leo_OpenAI_D_summary_dashboar... Gemini-3-Flash: https://files.sigmastratum.net/Leo_Gogle_D_summary_dashboard...
AEP metric dynamics (TI, SDC, L/N) GPT-5.2: https://files.sigmastratum.net/Leo_OpenAI_E_metrics_timeline... Gemini-3-Flash: https://files.sigmastratum.net/Leo_Gogle_E_metrics_timeline....
---
Takeaway
- Entropy can be regulated, not just randomized. - LLMs can maintain self-consistent reasoning over hundreds of cycles when given runtime feedback. - Structural stability (coherence, terminology, logic) doesn’t require retraining — only a dynamic control layer.
---
Report (DOI): https://doi.org/10.5281/zenodo.18271591 Code & appendix: https://github.com/sigmastratum/documentation
---
We’d love technical feedback on: - Runtime-level coherence control - Measuring “identity persistence” - Long-horizon reasoning tests (100+ turns)