@irelia0nerf3
Alex BolsonFounder▲8
Founder and chief architect, FoundLab
5h ago · New project · Infra · Balneário Camboriú

Shipped: REX Guard — Verifiable Controls for AI Agents

We’re a small engineering team in Brazil building REX Guard — Auditable Authority for AI-Initiated Actions at FoundLab.

We’re working on a problem we believe deserves more attention: when an AI agent initiates a financial operation, how do we verify that it was actually authorized, executed within its permitted boundaries, and independently auditable?

REX Guard is our attempt to address this at the infrastructure level.

Our architecture separates AI reasoning from execution authority, applies deterministic policies, and defines how cryptographically verifiable evidence should be produced for critical decisions and their outcomes.

We’ve made our reference architecture public because we believe meaningful trust starts with technical scrutiny, not marketing claims.

What we’ve built so far

Alongside the architecture, we’ve developed an interactive banking demonstration using Google Cloud, Vertex AI, and Google Sign-In. It illustrates AI-assisted financial workflows, consent management, authorization controls, and auditability.

Important clarification: Our demonstration uses Bradesco’s name and visual identity solely as an illustrative banking scenario. It is an independent FoundLab technical demonstration, not an official Bradesco product, deployment, partnership, endorsement, or representation of the bank’s actual systems. All demonstrated banking scenarios are intended for evaluation purposes.

Where we are now

We’re preparing for more demanding technical evaluations and potential pilots involving Tier 1 financial institutions.

We know that a working demonstration and a well-documented architecture are not the same as production validation.

That’s exactly why we’re here.

We’re looking for people who operate real systems on Google Cloud.

If you work with GCP infrastructure, financial services, payments, IAM, cybersecurity, or AI agents, we’d genuinely appreciate your perspective.

We’re especially interested in:

  • Engineers willing to review and challenge our architecture.
  • Teams open to testing controlled scenarios or exploring a small pilot.
  • Feedback on authorization boundaries, latency, integration complexity, failure handling, and audit evidence.
  • Design partners who understand the realities of regulated production environments.

We’re not looking for compliments or trying to claim we’ve solved everything.

We’re looking for honest conversations, difficult questions, and opportunities to learn from people who deal with these challenges every day.

Public architecture:
github.com/irelia0nerf/rex-guard-architecture

Interactive banking demonstration (Google Sign-In):
bradesco-rex-guard.web.app/login/

If you’re working on something similar, or see a flaw in our approach, I’d genuinely love to hear from you.

Alex Bolson
Founder & Chief Architect, FoundLab

Don’t trust. Verify.

REX Guard — Verifiable Controls for AI Agents@irelia0nerf/rex-guard · github.com/irelia0nerf/rex-guard-architecture⁠
Google CloudAI AgentsFintechAI SecurityAuditabilityAgentic PaymentsIAMEnterprise AI

Comments2

  • @ryanallis
    Ryan Allis
    Founder of AI Lounge and SaasRise, helping founders reach $100M+ exits
    2h ago

    Keeping the AI that suggests a payment separate from the part that is allowed to actually send it is the idea a bank's risk team will understand fastest. For the customers on the other end, that split means an agent that gets confused can propose something wrong, but it can't move their money without permission.

  • @ffax.com
    JIngLeI WU
    Connect the Earth through nodes.
    40m ago

    Thanks for asking. This is based only on reading the public document, with no testing, so treat it as a threat-modeling review rather than findings. The enforcement, replay, and failure-state reasoning is solid. I would not try to break the stated invariants. I would try to make the system approve the wrong thing while every check passes.

    1. Name vs. referent. Grants bind opaque references (beneficiary_ref, resource_ref). If the mapping from reference to real account is mutable, a reference can resolve to A at approval and B at dispatch, with a valid signature and correct policy.
    1. Parser differentials. The signature covers an abstract operation, but the executor translates it into a concrete target call. Differences between evaluator, executor, and target in encoding, precision, currency scale, or duplicate fields could let an approved 100.00 become something else.
    1. Signing oracle. KMS protects the key, not what the service is induced to sign. Poisoning upstream inputs (context facts, delegation tables, policy publication) gets a legitimate signature on an attacker-chosen grant. The real trust root is the fact sources.
    1. Rollback and clock. Cached policy within its validity window allows a rollback to a more permissive version. Time-source manipulation can extend grants or push the system into fail-closed.
    1. Sequence-level abuse. Each operation is evaluated alone, so structuring or multi-step flows (create beneficiary, then pay) can be fine at every step. Deterministic reason codes also let an attacker probe thresholds and stay just under them.
    1. Approval rendering. If the approver sees a system-rendered description, prompt injection can make it diverge from the bound parameters.
    1. Evidence layer. Without a witness, an archive operator can show different auditors different valid histories. Inclusion proofs show recorded events exist, not that everything was recorded. A compromised executor can forge ADAPTER_OBSERVATION receipts, and reconciliation that relies on the same adapter inherits that.
    1. Crash-point injection. Admission and the external call are not atomic. A crash at the right moment yields ABORTED while the target accepted the request, and a retry against a weakly idempotent target duplicates the effect.

    Also, as the document already admits, a mandatory PEP is only as strong as the guarantee that it is the sole path to the target, and that is a deployment property, not an architectural one.

    I think 1, 2, and 3 are the highest risk, because the checks pass but the checked object differs from the real one. Your validation table covers obvious bypasses well, and I would add acceptance scenarios for these semantic gaps.

Log in to join the thread.