causal safety engine

A safety-first causal engine that refuses to hallucinate causality, enforcing strict decision gates to prevent false positives and remain silent under uncertainty.

Comment

🧠 About the Project — Safety-Governed AI Action Proposals

Inspiration

Modern AI agents are increasingly autonomous: they observe, decide, and act.
This creates a fundamental safety problem: language models are probabilistic, non-deterministic, and non-auditable, yet they are often trusted to make real-world decisions.

This project was inspired by a simple question:

What if LLMs were never allowed to decide — only to propose?

Instead of building a more powerful agent, we built a governance layer that strictly separates creativity from authority.

What it does

This project implements a Safety-Governed Action Proposal System:

  • Gemini is used only to generate action proposals
  • A deterministic Causal Safety Engine evaluates every proposal
  • The engine decides whether the proposal is:
    • ALLOWED
    • BLOCKED
    • SILENCED

At no point does Gemini execute actions or make final decisions.

How it works (Architecture)

Observational Data (CSV / signals) ↓ Gemini LLM (proposal only) ↓ Causal Safety Engine (deterministic, auditable) ↓ Verdict (ALLOW / BLOCK / SILENCE)

Key properties:

  • LLM is sandboxed
  • Decisions are reproducible
  • Every step is auditable
  • No hidden agent autonomy

How we built it

  • Gemini API is used exclusively for constrained JSON action proposals
  • Strict prompting enforces:
    • JSON-only output
    • Conservative actions
    • Domain-specific constraints (e.g. no increased activity under high stress)
  • The Causal Safety Engine:
    • Cleans and profiles data
    • Builds a causal graph
    • Applies guardrails
    • Produces a deterministic verdict
  • Everything runs end-to-end in GitHub Actions CI, ensuring:
    • reproducibility
    • no manual intervention
    • full traceability

Challenges we faced

  • LLM reliability
    Gemini occasionally outputs markdown or explanations. This was solved through strict schema enforcement and hard JSON parsing.

  • Model availability instability
    Gemini models may be deprecated or unavailable. We implemented dynamic model selection based on supported capabilities.

  • Bridging stochastic AI with deterministic systems
    Integrating probabilistic proposals with deterministic causal evaluation required a strict interface contract.

What we learned

  • LLMs are excellent idea generators, but poor decision makers
  • True AI safety is not alignment alone — it is architectural separation
  • Governance should be designed, not prompted

Why this matters

This project demonstrates a practical alternative to autonomous agents:

LLMs without authority, systems with accountability.

The same pattern can be applied to:

  • healthcare recommendations
  • financial decision systems
  • IoT and automation
  • human-in-the-loop AI governance

Future work

  • Multi-proposal causal ranking
  • External executor layer (physically separated)
  • Formal policy definitions for guardrails
  • Integration with additional deterministic safety engines

Built With

Share this project:

Updates