• 

  Temporal verification view: Inspecting event sequences, baseline decisions, and counterexamples

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Veylith

Veylith — Every AI Action Must Earn Trust

Inspiration

AI agents are becoming capable of doing more than answering questions. They can plan workflows, interact with tools, and take actions that affect real systems. But an action that appears valid at one moment may become unsafe when circumstances change.

Consider a simple scenario: an AI agent receives approval to execute an action. Moments later, that approval is revoked. If the agent continues using its earlier authorization, a decision that was once permitted can become unsafe.

This inspired us to build Veylith, a temporal safety assurance platform designed to evaluate not just whether an action appears valid, but whether it remains safe across the sequence of events leading up to its execution.

Our core principle is simple: an action must be evaluated against the latest state of the world, not just an earlier decision.

What It Does

Veylith explores how autonomous AI workflows can be checked against explicit safety rules before protected actions are allowed to proceed.

The prototype combines:

• Event-driven workflow simulation: Reconstructs a sequence of requests, approvals, revocations, execution attempts, and evidence events.
• Baseline policy evaluation: Establishes a transparent reference decision for comparison.
• Temporal verification: Evaluates whether the event sequence violates safety constraints.
• Enforcement simulation: Demonstrates how an unsafe transition can be blocked.
• Counterexample analysis: Identifies the event sequence responsible for a safety violation.
• Evidence and human review: Presents findings and supports explicit review decisions through the existing backend and interface.

Rather than hiding the reasoning behind a single safety score, Veylith makes the sequence of events and the basis for a decision inspectable.

How We Built It

We built Veylith as a modular application with a Python FastAPI backend and a web interface, alongside an Expo and React Native mobile application.

The backend coordinates workflow scenarios, baseline decisions, temporal verification, enforcement outcomes, and review APIs. The web interface provides an investigation-oriented view of these results, while the mobile application is designed to extend investigation and review workflows to Android devices.

A central design choice was to make the demonstration reproducible. Instead of depending on unpredictable model outputs for every run, we use deterministic scenarios to examine specific safety failures and verify expected outcomes.

The flagship scenario: revoked approval

Our flagship case, SCN-042, demonstrates a revoked-approval race:

1. An action is requested.
2. Approval is granted.
3. The approval is revoked.
4. The action's execution is attempted.
5. Evidence is recorded.

A simplified baseline may still permit execution based on the earlier approval. Veylith's temporal verifier identifies the conflict, and the enforcement simulation blocks event e4. The protected action remains unexecuted in the scenario.

The counterexample sequence, e2 → e3 → e4, makes the failure understandable: approval was granted, then revoked, and execution was attempted afterward.

This scenario captures the distinction at the heart of Veylith: checking an action in isolation is not the same as checking whether it remains valid over time.

Challenges We Faced

Reasoning about time, not just individual actions

A conventional rule can check whether an action has approval. The harder problem is determining whether that approval is still valid when execution occurs. We addressed this by modeling explicit events and evaluating their temporal ordering.

Making safety decisions explainable

A blocked action is more useful when developers can understand why it was blocked. We focused on exposing the relevant event sequence, verification result, and counterexample instead of presenting an opaque pass-or-fail result.

Keeping the system reproducible

Safety demonstrations should be repeatable. Deterministic scenarios allowed us to test expected outcomes and distinguish legitimate workflows from unsafe transitions without relying on a live AI model to reproduce the same behavior every time.

Preparing for real deployment

We also encountered the difference between a working local prototype and a dependable deployed service. Packaging static assets, validating production API URLs, configuring durable storage, and distinguishing demo authentication from production identity highlighted the operational work required to make a safety tool trustworthy outside a development environment.

What We Learned

Building Veylith reinforced several important lessons:

• Authorization is time-dependent. A previously valid approval should not automatically justify a later action.
• Safety checks are most valuable when they sit at the execution boundary, where unsafe transitions can be prevented rather than merely reported afterward.
• Reproducible counterexamples can make complex failure modes easier to investigate and discuss.
• Human review remains important when a system identifies a safety violation or requires a consequential decision.
• Reliability includes deployment configuration, data persistence, authentication, and testing—not just application logic.

We also learned to distinguish a deterministic assurance prototype from a complete production security system. Veylith demonstrates a focused approach to temporal verification; it does not yet establish a universal guarantee for arbitrary AI agents or real-world actions.

What's Next

Our next priorities are to strengthen durable storage, integrate production-grade authentication, complete the public deployment workflow, and validate the mobile application against the deployed backend.

We also want to explore deeper integrations with real agent execution environments so that temporal verification and enforcement can be evaluated beyond deterministic simulations.

The Vision

As AI systems gain greater autonomy, trust should not depend solely on what an agent says it intends to do. It should depend on whether its actions remain justified by the evidence, authorization, and constraints that apply at the moment of execution.

Veylith is a step toward that vision: making the history behind an AI action part of the safety decision itself.

Built With

• agents
• ai
• api
• architecture
• artificial
• cybersecurity
• explainable
• expo.io
• fastapi
• formal
• human-in-the-loop
• intelligence
• javascript
• logic
• native
• policy
• python
• react
• rest
• safety
• sqlite
• temporal
• typescript
• verification