PersistentAIOrchestration Layer for Transactional AI

Overview ​

PersistentAI is an open source deterministic orchestration (DO) framework for building AI agents and automation systems with complex, verifiable logic. It is engineered for mission-critical, high-load operational environments — such as financial back-office systems, user intent processing, and agentic commerce — delivering fault-tolerant, deterministic flows and enterprise-grade reliability.

The framework addresses a fundamental deficiency in the contemporary AI stack: the absence of a deterministic orchestration layer between probabilistic foundation models and mission-critical end-user applications. Without such a layer, AI agents remain structurally unreliable for any operation involving money, identity, or irreversible state changes. PersistentAI provides that layer.

PersistentAI spans the core functional layers of the agentic AI stack — providing the runtime, orchestration, and enrichment foundation on which agentic systems operate. It bridges AI logic, protocol interoperability, workflow orchestration, and tool integration into one cohesive execution layer.

The execution engine at the core of PersistentAI is FireFlow — a deterministic orchestration runtime with exactly-once execution semantics via DBOS, eliminating the hallucination and non-determinism risks inherent in generative AI. This architecture enables the deployment of AI agents in high-stakes sectors such as finance and identity, where structural reliability is a non-negotiable requirement.

Value Proposition for Institutions ​

As AI agents proliferate across the financial sector — both customer-facing co-pilots and internal digital employees — "agent sprawl" creates operational chaos. Without deterministic orchestration, institutions face catastrophic risks from AI errors in critical operations. PersistentAI serves as the central nervous system for post-AI financial infrastructure, from user intent-driven UX to back-office process automation.

From the institutional viewpoint, PersistentAI enables organizations to build and deploy custom agents for any business logic — whether loan advisory, investment recommendations, fraud detection, or account management. Once integrated into existing chat interfaces, a smart routing assistant automatically invokes the right specialized agent based on customer intent, delivering precise, context-aware responses in real time. This constitutes a single conversational entry point that connects customers to dozens of purpose-built AI capabilities — without managing separate bots or complex handoff logic.

PersistentAI provides a visual flow builder for back-office teams to design, deploy, and manage AI agents without writing code. Business logic is configured through drag-and-drop nodes, making it straightforward to create, modify, and scale intelligent workflows across departments. Every operation is logged and auditable, supporting deterministic execution for high-value operations such as trading or settling transactions.

The platform integrates the following functional systems, each essential for reliable agentic infrastructure in regulated environments:

• Agent Runtime & Orchestration: FireFlow provides the visual workflow builder and execution engine for coordinating multi-agent logic, tool integration, and complex event-driven pipelines.
• Settlement Infrastructure: The Agentic Settlement Layer (ASL), powered by TetraChain (TON L2), provides high-throughput, low-latency payment rails for Agent-to-Agent (A2A), Human-to-Agent (H2A), and Agent-to-Human (A2H) transactions, supporting private identity, KYC delegation, and compliance via zero-knowledge proofs.
• DeFi & Traditional Protocol Mesh: Direct, secure connectivity to decentralized finance primitives and legacy financial gateways, enabling hybrid product composition — from automated yield strategies for retail clients to bespoke derivative instruments for sophisticated investors.
• Identity & Compliance Layer: A unified system managing decentralized identity (DID), user consent, and regulatory adherence, feeding the orchestration engine.

This infrastructure allows for the dynamic composition of structured financial products from DeFi primitives, all orchestrated by AI. It must be noted that without formal deterministic orchestration, allowing probabilistic generative AI models to compose structured products exposes the organization to extremely high risks resulting from models hallucinating in mission-critical situations. This underscores the non-negotiable importance of DO platforms such as PersistentAI.

User Intent Orchestration (UIO) ​

PersistentAI introduces what we term User Intent Orchestration (UIO): the paradigm shift from reactive navigation across fragmented applications to proactive, intent-driven fulfillment via autonomous economic agents. UIO moves beyond menu-driven interfaces to a proactive, contextual experience. The system interprets a user's broader goal and automatically orchestrates the necessary services, data, and execution steps across all relevant systems. This transforms complex multi-step workflows into a single, fluid conversation.

UIO enables institutions to deploy Autonomous Co-pilots that shift the user's role from active operator to strategic overseer. Users delegate routine and complex tasks — optimizing savings, rebalancing portfolios, identifying optimal lending rates — to a trusted AI agent. This creates a persistent engagement layer where the co-pilot acts on the user's behalf, deepening reliance and freeing users from manual operational burden.

UIO platforms, with user consent, securely aggregate and analyze data from across a user's financial ecosystem — checking accounts, investments, crypto wallets, and third-party services. This unified intelligence enables radically more insightful decision-making, identifying hidden opportunities or risks and optimizing the user's entire financial position rather than offering isolated, product-specific suggestions.

Bank Process Orchestration (BPO) ​

Concurrently, back-office AI agents act as digital employees, automating tasks in compliance, risk management, and treasury operations with significant efficiency gains. This advances the model of the "agentic institution" where human employees orchestrate teams of AI agents that execute back-office and administrative tasks on their behalf. Institutions not adopting the agentic stack for back-office automation risk becoming uncompetitive when compared to leaner and more agile digital-native competitors.

BPO delivers measurable operational improvements: real-world implementations demonstrate cost reductions exceeding 30% while handling increased volume, data accuracy improvements from 92% to 99.3% in document processing, and handling time reductions of 78%. Adaptive process orchestration allows institutions to dynamically adjust workflows, identify bottlenecks, and continuously optimize processes in response to changing regulatory and market demands.

The Case for Formal Determinism ​

The orchestration engine for financial AI requires guarantees of correctness, auditability, and resilience. FireFlow's architecture — emphasizing deterministic flows, type-safe data systems, and secure, auditable runtime environments — is engineered for this purpose. It ensures orchestration decisions are reliable, side-effect-free, and compliant, significantly mitigating the "black box" risks associated with non-deterministic AI in financial contexts.

The following properties are not features added to a chatbot; they are foundational properties of an execution engine designed for economic activity:

• DBOS (Durable Execution) — Every workflow step is persisted to PostgreSQL before proceeding. Exactly-once execution, automatic recovery from infrastructure failures, and time-travel debugging for any operation.
• TetraChain (Verifiable Settlement) — Every interaction and execution step is immutably recorded on TetraChain (TON L2). Sub-second finality, fraud proofs with economic slashing, and throughput required for agentic micropayments at scale.
• x402 (Native Micropayments) — HTTP-native payment protocol enabling instant, per-inference fee distribution. Automatic revenue splits across model providers, node creators, data providers, and protocol treasury.

Versioned Data Layer ​

PersistentAI includes a built-in Git-native file system for AI workflows — the Virtual File System (VFS), powered by lakeFS. Every file change is a versioned commit with the same branching, diffing, and rollback semantics as Git, applied directly to data. This is not just storage — it is the persistence layer that makes AI pipelines reproducible, auditable, and collaborative.

VFS operates under the same DBOS exactly-once guarantees as the execution engine. All file writes, moves, and deletes are durable workflows — no partial writes, automatic retry on failure, full audit trail.

• Branching & history — Create branches, commit, diff, and merge file trees. Roll back any dataset to any prior commit. Full data lineage for every AI pipeline run.
• Durable file operations — Writes, moves, and deletes execute as DBOS workflows with exactly-once semantics. No partial state. Automatic recovery on failure.
• Events trigger flows — 22 event types (FILE_MODIFIED, BRANCH_CREATED, COMMITTED, and more) can automatically spawn flow executions. Drop a file into a workspace and a pipeline runs.
• 15 VFS nodes — Read, write, edit, glob, grep, stat, copy, delete, and git-commit directly from the visual flow editor, with no code required.
• Flow packages as files — .fflow directories stored in VFS contain the complete flow definition. Flows are versioned, diffable, and shareable like source code.
• Multi-tenant workspaces — Isolated storage per user, team, or system with owner/editor/viewer roles. Conflict resolution on move and copy operations is handled via an interactive DBOS confirmation loop.

Technical Description ​

FireFlow is PersistentAI's source-available DO framework for building AI agents and automation systems with complex, verifiable logic. It is engineered for mission-critical, high-load operational environments, delivering fault-tolerant deterministic flows and enterprise-grade SLAs.

FireFlow's functionality is delivered through five integrated systems working in concert:

• Type-Safe Port System: Supports primitives and complex types (arrays, objects, streams, enums). Each port carries its own configuration and runtime validation (Zod, SuperJSON), with lazy instantiation and caching for efficiency.
• Modular Nodes: Build custom nodes with decorators and metadata. Multiple input/output ports integrate seamlessly into the flow builder for rapid workflow creation. A catalog of 146+ pre-built nodes spans 16 categories including AI & Intelligence, Blockchain & DeFi, Data Transforms, and Flow Control.
• Visual Flow Editor: Graphical flow builder (React + XYFlow) with drag-and-drop, zoom/pan, resizing, menus, and live previews.
• Execution & Debugging: Backend engine runs flows concurrently with real-time events, breakpoints, step-over, and detailed logs for debugging.
• Real-Time Sync: Uses tRPC and Effector for end-to-end type safety, WebSocket updates, and optimistic UI.

Integration with external systems is designed for extensibility. Any machine-readable service, API, or data source can be integrated through one of three approaches:

• MCP Native: PersistentAI supports Model Context Protocol (MCP) — an open standard enabling AI models to connect with external data sources and tools. Automatic node generation from any MCP server URL, with dynamic capability discovery and continuous synchronization.
• HTTP Request Nodes: Built-in nodes that call any REST API directly from workflows. Zero-code configuration of endpoints, methods, headers, and body directly in the visual editor.
• Custom Nodes (TypeScript): The most granular extension path. Leveraging the declarative decorator-based API (@Node, @Input, @Output), developers define node metadata and port configurations with minimal boilerplate. The framework handles TypeBox/Schema validation, dynamic UI generation, and port-to-port data mapping automatically.

Platform-Specific Application: Telegram ​

While PersistentAI is platform-agnostic in its core architecture, Telegram represents a particularly compelling deployment substrate. With over 1 billion monthly active users and a thriving ecosystem of Mini Apps (TMAs), Telegram constitutes one of the richest environments for encapsulating and resolving user intents at scale.

PersistentAI integrates Telegram's TMA and public group ecosystem through bidirectional transformation: any TMA, data source, or external service becomes a composable FireFlow node with defined I/O ports and an x402 payment endpoint — while any agentic flow built on the platform can itself be deployed as a TMA. This creates compounding network effects: each new node increases the value of the orchestration engine's compositional surface, and each deployed TMA generates x402 revenue for its component creators.

The AG-UI Protocol (Agent-Generated User Interface) enables AI agents to propose context-aware UI components — charts, product cards, forms, confirmations — rendered in real-time within the Telegram chat interface. Every front-end element is a deterministic wrapper around existing node output ports and fields, not probabilistically generated code.

The Agentic Settlement Layer (ASL), powered by TetraChain, serves as the high-throughput payment rail for executions happening throughout the PersistentAI ecosystem. Every node operates as an independent economic agent via an x402 port, facilitating autonomous, per-inference micropayments. This framework enables the tokenization of inference, where AI logic and datasets are represented as NFTs with automated revenue splits settled instantaneously on-chain between providers, creators, and owners.

The result is that a user types a complex, multi-constraint request into a single Telegram thread, and the orchestration engine decomposes it into parallel execution across dozens of autonomous nodes, settles micropayments to every economic participant, and renders an interactive, auditable result — all without the user leaving the chat.

Quick Start ​

Clone the repository and install dependencies:

git clone https://github.com/Persistent-AI/fireflow.git
cd fireflow
pnpm install
pnpm build

Start the database using Docker Compose:

docker compose -f docker-compose.yaml up -d && \
  docker compose -f docker-compose.vfs.yaml up -d

Run migrations to create the necessary database schema:

pnpm run migrate

Start the development environment:

pnpm run dev

📖 For detailed installation guides, see Developer Docs.

🎨 For the visual flow editor, see User Guide.

Links ​