Inspiration

AI agents are becoming increasingly capable of handling complex tasks, but giving them access to financial operations introduces a much bigger challenge: How do we make AI-driven financial execution reliable, controlled, and safe? Building a financial AI agent from scratch requires developers to repeatedly implement tool integrations, permission management, transaction safeguards, memory persistence, approval workflows, and execution monitoring. We realized that the real problem wasn't simply building another AI payment assistant. It was building the infrastructure that makes multiple financial AI agents trustworthy. That idea inspired DelTix a financial-agent compiler and runtime platform that transforms natural-language instructions into validated, policy-governed, executable AI agents.

What it does

DelTix allows developers to describe financial automation workflows in natural language and convert them into structured, executable AI agents. Instead of allowing an LLM to independently decide which financial APIs to call, DelTix introduces a structured compilation pipeline, a predefined capability registry, and a deterministic policy enforcement layer. The platform is designed around six fundamental capabilities: Natural Language Compilation: Converts user instructions into a structured Agent Intermediate Representation (Agent IR). Capability Registry: Provides a controlled collection of approved financial tools and typed PayPal Sandbox adapters. Deterministic Policy Enforcement: Validates permissions, transaction limits, and execution constraints outside the LLM. Automated Validation: Generates synthetic positive, negative, and failure-recovery tests before an agent can become executable. Human-in-the-Loop Approvals: Pauses sensitive operations for explicit developer or human approval. Persistent Execution Memory: Uses Supabase and Redis to support resumable workflows, checkpointing, deduplication, and safe distributed execution.

How we built it

We designed DelTix as a four-stage, modular architecture.

  1. Compiler Service — Go 1.23 The compiler accepts natural-language instructions, identifies the intended financial workflow, extracts constraints, and generates a structured Agent IR. This intermediate representation acts as a reviewable specification before execution logic is created. The generated specification is persisted in Supabase, ensuring that agent definitions remain structured and traceable.

  2. Configuration, Capability & Policy Service — Go 1.23 This service resolves requested operations against a predefined capability registry. Rather than trusting the LLM to invent or select arbitrary payment APIs, DelTix only permits registered capabilities. A deterministic policy enforcement layer validates permissions and execution constraints independently of the language model. Redis provides idempotency and distributed coordination to help prevent duplicate financial operations.

  3. Validator Engine Before deployment, an agent must pass a validation pipeline. The validator checks: Agent IR schema correctness. Capability availability and policy conflicts. Positive execution scenarios. Negative and unauthorized operation scenarios. Failure recovery and retry behavior. Only agents that successfully pass validation proceed to developer approval.

  4. Runtime Service — Go + Python LangGraph

The runtime combines a Go-based controller with Python-based LangGraph execution workers. LangGraph manages stateful workflows, conditional routing, execution loops, and human-in-the-loop interruptions. Supabase (PostgreSQL 16 + pgvector) provides transactional storage, execution checkpoints, audit records, and semantic memory. Mem0 supports long-term memory for merchant preferences and recurring case patterns, while Redis provides distributed locking and deduplication. Finally, typed PayPal Developer Sandbox adapters handle payment and refund operations using PayPal-Request-Id idempotency keys. All financial execution is restricted to the PayPal Developer Sandbox.

Challenges we ran into

  1. Preventing unpredictable AI behavior

An LLM should never have unrestricted authority over financial operations. We addressed this architectural challenge by separating AI reasoning from deterministic Go-based policy enforcement.

  1. Preventing duplicate transactions

Distributed systems introduce retry and concurrency challenges. We designed Redis-based deduplication, distributed locking, and PayPal request idempotency into the execution architecture.

  1. Managing long-running workflows

Financial workflows may require human intervention before continuing. We designed checkpoint-based execution with LangGraph and Supabase so workflows can pause and resume without relying on continuously running processes.

  1. Making agents testable before execution

A generated agent should not automatically be trusted. We introduced a validation stage that checks schemas, permissions, negative scenarios, and failure recovery before developer approval.

Accomplishments that we're proud of

We are proud of designing DelTix as more than just another AI-powered payment application. We set out to build a reusable infrastructure layer that makes financial AI agents safer, more reliable, and easier to deploy.

Our biggest accomplishment is bringing together compiler design, deterministic policy enforcement, AI orchestration, distributed systems, and financial API integration into one cohesive architecture.

We are particularly proud of:

  • Specification-first agent generation: Designing an Agent Intermediate Representation (Agent IR) that makes generated agents structured, reviewable, and predictable before execution.
  • Safety beyond prompting: Separating LLM decision-making from deterministic Go-based policy enforcement.
  • Reliable financial execution: Incorporating Redis-based deduplication, distributed locking, and PayPal request idempotency into the architecture.
  • Resumable AI workflows: Designing stateful LangGraph execution with Supabase checkpointing and human-in-the-loop interruptions.
  • Test-gated deployment: Making positive, negative, and failure-recovery validation an essential step before an agent becomes executable.

Most importantly, we are proud of approaching financial AI from an infrastructure-first perspective. Instead of solving one payment use case, we designed a foundation that can support multiple specialized financial agents.

What we learned

Building DelTix taught us that developing reliable AI agents involves much more than connecting an LLM to a set of APIs.

We gained a deeper understanding of how compiler architecture, distributed systems, backend engineering, and AI orchestration can work together to solve real-world problems.

Some of our biggest learnings were:

  • AI needs deterministic boundaries: LLMs are powerful at understanding intent and proposing actions, but sensitive financial operations require independent policy enforcement.
  • Idempotency is essential in financial systems: Retries and network failures must not result in duplicate payments or refunds.
  • State management matters: Long-running AI workflows need persistent checkpoints, controlled interruptions, and reliable recovery mechanisms.
  • Tool access must be controlled: A capability registry provides a safer alternative to allowing AI models to invent or invoke arbitrary APIs.
  • Testing is part of the architecture: Validation should not be an afterthought, especially when an AI agent can initiate financial operations.
  • Human oversight builds trust: Sensitive actions should have clear approval boundaries and traceable execution histories.

We also learned how to think across multiple technology ecosystems, integrating Go for deterministic control, Python and LangGraph for agent orchestration, Redis for distributed coordination, and Supabase for persistent state and memory.

The biggest takeaway was that trustworthy AI is not achieved through better prompts alone; it requires carefully engineered systems around the model.

What's next for DelTix

Our vision for DelTix extends beyond the PayPal Developer Sandbox. We want to evolve it into a reusable platform for creating, validating, deploying, and monitoring trustworthy financial AI agents.

Our next priorities include:

  • Expanding the capability registry: Introducing more financial operations and reusable, typed integrations while maintaining strict permission boundaries.
  • Advanced policy configuration: Supporting customizable transaction limits, role-based permissions, approval thresholds, and risk-aware execution rules.
  • Richer agent simulation: Building more comprehensive test environments with adversarial inputs, network failures, retry scenarios, and edge-case transaction testing.
  • Improved observability: Extending LangSmith tracing and execution analytics to provide deeper insights into agent decisions, latency, failures, and transaction lifecycles.
  • Persistent merchant intelligence: Enhancing Mem0 and pgvector-based semantic memory to support contextual preferences and recurring financial workflows.
  • Production readiness: Strengthening authentication, authorization, monitoring, deployment, and security controls before considering integrations beyond sandbox environments.
  • Developer experience: Creating a more intuitive interface where developers can describe workflows, inspect generated Agent IR, configure policies, review test results, and manage running agents.

Ultimately, we want DelTix to become the infrastructure layer developers reach for when building financial AI agents.

Our long-term goal is simple: make creating a financial AI agent as straightforward as describing what it should do, while ensuring that how it executes remains controlled, transparent, and trustworthy.

Built With

Share this project:

Updates

Submission history