Inspiration
AegisState was inspired by a critical challenge in autonomous AI: an agent can take consequential actions even when its behavior exceeds its intended scope or the information supporting its decisions is no longer reliable.
The urgency is reflected in published research and industry reports. In April 2026, the Cloud Security Alliance reported that 65% of 418 surveyed IT and security professionals said their organizations had experienced AI-agent-related incidents in the preceding 12 months. A separate NeurIPS 2025 study documented more than 60,000 successful policy violations across 1.8 million prompt-injection attacks in a large-scale red-teaming competition. These findings highlight the need for stronger controls over agent behavior.
AegisState approaches this problem from the decision-integrity layer. Rather than attempting to make agents reason perfectly, it tracks dependencies between evidence and decisions, identifies decisions affected by evidence changes, and blocks protected actions that rely on stale decisions while preserving unaffected ones.
The goal is to make AI-agent workflows more accountable and resilient by ensuring that a decision is not treated as permanently valid simply because it was valid when first made.
What it does
- Dependency-Aware Decision Tracking
AegisState represents relationships between evidence and decisions as a dependency graph. When evidence changes, it identifies downstream decisions that may no longer be valid, without unnecessarily invalidating unrelated decisions.
- Protected Execution
Before a protected action runs, AegisState checks whether its supporting decision remains valid. If the evidence has changed and the decision is stale, the action is blocked.
- Replay Protection and Persistence
AegisState uses replay identifiers to detect duplicate submissions and SQLite to persist replay records across restarts.
- Performance and Reliability Testing
Benchmarks evaluate graph operations at 100, 500, and 1,000 nodes. Automated tests cover dependency updates, concurrency, protected execution, and failure recovery. https://ibb.co/7dSrrTRS
- Agent Workflow Integration
A LangGraph demonstration shows how workflow orchestration can work alongside AegisState's decision-integrity checks. The workflow allows an action when its decision remains valid and blocks it when supporting evidence has changed.
- Installation and Local Dashboard
Developers can install AegisState using "pip". The project includes a Python library, a Streamlit demonstration dashboard, SQLite-backed replay storage, documentation, and automated tests.
How we built it
AegisState is a modular, pip-installable Python package that separates decision-integrity enforcement from the AI agents making decisions. Its core engine uses dependency tracking, evidence versioning, and deterministic validation rules without requiring an LLM or hosted AI service.
- Architecture and Workflow
An AI agent or external application submits a structured report. AegisState validates the report, checks the dependencies behind the decision, and determines whether a protected action can proceed.
Workflow:
AI Agent / External Application ↓ Structured Report ↓ Report Validation and Security Bridge ↓ AegisState Engine
- Dependency Tracking
- Evidence Versioning
- Decision Provenance
- Stale-State Detection ↓ Protected Executor
- Valid decision → Allow action
- Stale or invalid decision → Block action
Supporting components: SQLite replay protection, Streamlit dashboard, and automated tests.
- Dependency-Aware Validation
AegisState models evidence and decisions as a directed dependency graph. When evidence changes, it identifies affected downstream decisions while preserving unrelated decisions.
A decision remains valid only if it has not been invalidated, its dependencies remain valid, and the evidence versions match those recorded when the decision was committed.
The engine uses graph traversal and iterative processing to validate dependencies and detect circular relationships. For graph traversal, the time complexity is (O(V+E)), where (V) represents tracked items and (E) represents dependency edges, under the usual assumption that each node and edge is processed a bounded number of times.
- Security and Persistent Storage
AegisState includes structured report validation, protected execution, and replay protection against duplicate report submissions.
SQLite stores replay identifiers and processing statuses persistently across application restarts. This helps prevent duplicate processing, while remaining separate from the engine's in-memory dependency state.
The core engine runs locally without requiring a hosted AI service or a separate database server.
- Performance and Reliability
We benchmark graph operations at 100, 500, and 1,000 nodes to evaluate performance as graph size increases.
The automated test suite covers dependency validation, evidence updates, protected execution, report ingestion, concurrency, failure recovery, SQLite persistence, and replay protection. Benchmarks measure performance; automated tests check implemented behavior.
- Integration and Developer Experience
AegisState includes a LangGraph integration demonstration showing how workflow orchestration can work alongside decision-integrity checks.
The project also provides an installable Python package, installation documentation, example workflows, a Streamlit dashboard, and automated tests. These components let developers explore the engine and integrate its checks into their own applications.
AegisState is a practical decision-integrity layer not a replacement for AI models or a guarantee against every agent failure. Production use still requires appropriate integration, security review, and operational testing.
Challenges we ran into
One of the biggest challenges was translating the idea of decision integrity into practical, testable logic. Detecting that evidence has changed is not enough; the system must also determine which decisions depend on that evidence and which can remain valid.
Another challenge was structuring AegisState as a reusable Python package rather than a script that only works in a local demonstration. This required separating components, managing dependencies between modules, and making installation and integration clearer for other developers.
Testing was also important. As the system grew to include report ingestion and additional validation workflows, we encountered integration issues and test failures that required us to trace problems across components and refine the implementation.
Working through these challenges helped shape AegisState into a more structured, testable engineering tool, with an emphasis on predictable behavior, clear validation outcomes, and maintainability.
Accomplishments that we're proud of
.Accomplishments We're Proud Of
We turned a specific AI-agent reliability problem into a working, reusable Python package not just a concept or a dashboard.
- Built a dependency-aware integrity engine that tracks evidence-to-decision relationships, detects stale decisions, and selectively invalidates affected dependencies while preserving unrelated decisions.
- Implemented protected action execution so applications can block actions that depend on invalid decisions.
- Added persistent replay protection using SQLite, with report tracking designed to survive application restarts.
- Built structured report-ingestion workflows to connect external decision reports to the engine.
- Packaged AegisState for local installation through pip, with documentation and an optional Streamlit dashboard.
- Validated the implementation with an automated test suite, covering core engine behavior, evidence changes, report ingestion, protected execution, and replay protection.
What we're most proud of is the engineering principle behind AegisState: a decision should not remain trusted simply because it was valid once. We built a system that makes decision validity dependent on the evidence and state supporting it.
What we learned
Building AegisState taught us that reliable AI-agent systems need more than accurate decisions at a single point in time. They also need mechanisms for handling changes in the evidence those decisions depend on.
We learned the importance of explicitly tracking dependencies instead of treating decisions as isolated results. When underlying evidence changes, the system must identify which decisions are affected while preserving those that remain valid.
We also learned that good engineering goes beyond implementing the core algorithm. Package structure, automated testing, documentation, error handling, and a clear demonstration interface all contribute to making a project easier to understand, verify, and reuse.
Finally, building AegisState reinforced the value of testing assumptions against actual system behavior. Turning an abstract reliability problem into a working implementation required breaking it into smaller components, testing them independently, and verifying that they worked together.
The biggest lesson was that decision reliability is not just about whether a decision was correct when it was made, but whether it can still be trusted when the underlying state changes.
What's next for AegisState
Future development will focus on broader real-world adoption of AegisState, including additional agent-framework integrations, evaluation in more complex workflows, and stronger support for production deployment.
Further work could explore distributed coordination, cross-process state consistency, and comprehensive deterministic workflow replay.
These improvements would extend AegisState beyond its current local execution model while preserving its core principle: validating decisions against the evidence they depend on before protected actions proceed. These improvements aim to make AegisState easier to integrate, evaluate, and operate in real-world AI-agent workflows.
Log in or sign up for Devpost to join the conversation.