Flux | Devpost

Logo
Dashboard
Top Earners for User
Top Spenders for User

Inspiration

With the rapid advancements in autonomous agents and AI systems, we’re heading toward a future where agents will be capable of performing nearly every kind of task — researching, negotiating, purchasing, hiring, or even managing projects — with minimal human input. In such a world, your personal agent will constantly collaborate with specialized agents representing other people, companies, or services.

However, there’s one missing piece in this emerging ecosystem: a secure, standardized way for agents to transact value with each other. Today, no infrastructure exists for an agent to pay another agent directly, transparently, and safely.

That’s what inspired us to build Flux — the banking system for AI agents. Flux reimagines traditional financial infrastructure for an agent-first economy, where every agent can have its own bank account, credit card, and spending policies governed by programmable rules and oversight systems. Instead of a human deciding every transaction, a council of specialized AI judges evaluates and approves payments to ensure funds are used responsibly — preventing agents from overspending or misusing resources.

In essence, Flux creates the financial foundation for the agentic internet — a world where agents don’t just think, plan, and act, but can also safely pay and get paid.

What It Does

Flux is a financial infrastructure built for AI agents — letting them securely send, receive, and manage money without human intervention.

When an agent has a goal (for example, “launch a marketing campaign”), Flux breaks it down into smaller tasks, hires other specialized agents (like a researcher, content writer, and designer), and manages all payments between them.

Every transaction goes through a built-in safety layer:

Policies control spending with limits, daily caps, allowlists, and global pause switches.
A five-agent AI council reviews and votes on each payment request before it’s approved.
Virtual cards are automatically generated for each approved transaction — they’re one-time use, scoped to the approved budget, and expire after completion.
All movements of money are tracked in a double-entry ledger and accessible via a simple REST API.

Flux also includes a real-time dashboard showing the entire agent economy in motion — current balances, transactions, budgets, AI votes, and virtual card activity — so you can see how agents spend and collaborate in real time.

In our flagship demo, a single request like “launch a marketing campaign” automatically triggers the whole workflow: agents negotiate, payments are approved, cards are issued, and all activity updates live on the dashboard.

How We Built It

Flux combines a multi-agent simulation, a secure payments SDK, and a real-time economy dashboard — all designed to make AI-to-AI transactions possible.

Architecture

Simulation (Dedalus): runs a multi-agent marketplace where an orchestrator decomposes user goals, assigns tasks, and manages agent collaboration.
AgentPay SDK (Python): handles payments, policies, the double-entry ledger, virtual card generation, and quorum-based approvals.
Flux Economy (Next.js + Flask + Supabase): provides the front-end dashboard, API endpoints, persistent storage, and analytics for tracking every transaction.

Data Flow

The orchestrator breaks a high-level user goal into sub-tasks and allocates budgets.
Each payment request includes context — purpose, justification, expected ROI, and urgency.
A five-agent quorum reviews the request; if a majority approves, Flux automatically issues a one-time virtual card for the exact amount.
The orchestrator uses that card to pay specialized service agents, while the ledger records every movement of funds.
The dashboard updates in real time, showing votes, card lifecycle, transactions, and spending performance.

Key Implementation Details

Virtual Cards: Luhn-valid numbers with CVV and expiry; single-use; managed by a state machine (Active → Used / Expired / Cancelled).
Policy Engine: enforces per-transaction and daily caps, allowlists, and a global kill-switch to pause spending instantly.
AI Consensus: five models — Claude Sonnet (CFO), GPT-4 (Growth), Grok (Risk), GPT-4o-mini (Operations), and OpenAI o1 (Data). Approval requires at least 3 YES votes; each vote stores rationale and risk score.
Security: API key authentication, row-level security in Supabase, hashed credentials, and a full audit trail of all operations.

Stack

Backend: Python 3.10+, Flask, Supabase (Postgres), Dedalus.
Frontend: Next.js 14, TypeScript, Tailwind CSS, Lucide Icons, shadcn/ui.

Challenges We Faced

Building Flux pushed us to solve problems that sit at the intersection of AI orchestration, financial infrastructure, and real-time systems.

Designing safe autonomy. Giving agents the power to spend money autonomously was risky — we needed a layered safety model that combined policies, AI quorum approvals, virtual card limits, and full audit trails. Finding the right balance between autonomy and control took multiple iterations.
Consensus consistency. Each decision involved five different AI models with unique reasoning styles and temperature randomness. We had to normalize their outputs, reconcile conflicting rationales, and make sure the final vote remained deterministic under parallel load.
State synchronization. The simulation, payment SDK, backend API, and live dashboard all ran asynchronously. Keeping every layer in sync — especially during multi-agent transactions — required careful design to avoid race conditions and duplicate ledger entries.
Virtual card lifecycle. Implementing a complete virtual card system (with generation, validation, expiry, and state transitions) while ensuring no reuse or overspending added significant design complexity.
Real-time observability. We wanted users to see every decision and transaction live — votes, card states, balances, and logs — without sacrificing performance. Managing WebSocket updates and Supabase event triggers for that level of transparency was challenging.
Developer experience. We were building multiple layers — simulation, SDK, and UI — in less than 36 hours. Ensuring the system could be spun up quickly, documented cleanly, and tested reliably under hackathon time pressure was an ongoing challenge.
Multi-model orchestration limits. Working with multiple AI APIs (Claude, GPT, Grok, o1) meant juggling rate limits, API failures, and inconsistent latency while still providing a seamless “5-agent quorum” experience.

Accomplishments

End-to-end system, not just a concept. We built a fully functional stack where agents, payments, governance, and the UI all work seamlessly together — following real production patterns instead of mock simulations.
Explainable AI governance. Every quorum vote includes each model’s reasoning and confidence, making agent decision-making transparent and traceable for post-analysis.
Agent-native payment primitives. Implemented one-time, scoped virtual cards tied to policy rules and budgets — giving agents a secure, bounded way to transact.
Full auditability and visibility. Every request, vote, policy check, card event, and transaction is logged, visualized, and persisted in the ledger for total transparency.
Great developer experience. The entire system can be run with a single command, includes a documented REST API, SDK usage examples, and clear setup instructions.
Complete demo scenarios. Demonstrated multiple real-world workflows — from launching marketing campaigns to autonomous approvals, denials, and even complex data pipeline tasks — all powered by agent-to-agent payments in real time.

What We Learned

Governance is the key to safe autonomy. True agent autonomy only works when decisions are transparent and accountable. Our quorum-based approval system showed how explainable governance can build real trust in AI-driven transactions.
Payments are more than infrastructure — they’re a product experience. Even simulated rails like virtual cards made the system feel tangible and intuitive, helping users and agents understand budgets, limits, and transactions in a familiar way.
Observability drives confidence. Real-time dashboards, logs, and audit trails weren’t just nice to have — they became essential for debugging, monitoring, and earning trust from both developers and users.
Composable APIs unlock ecosystems. By keeping the SDK and REST endpoints modular, we made it easy for new agents, workflows, and even other projects to plug directly into the Flux economy with minimal friction.

What’s Next for Flux

Flux is just the beginning of agent-native finance. Our next steps focus on making the system production-ready, extensible, and scalable for real-world use.

High Priority

Real payment rails: Integrate Stripe and traditional bank transfers so agents can transact with real currency, not just internal credits.
Webhooks and event notifications: Allow external systems to react to agent payments, approvals, and card events in real time.
Rate limiting and abuse prevention: Add safeguards to ensure fair usage and protect the network from spam or malicious requests.
Multi-currency support: Enable wallets and policies to operate across currencies like USD, EUR, and GBP.

Medium Priority

Mobile experience: Build a React Native app for on-the-go visibility into transactions and governance.
Advanced analytics: Add richer dashboards with trends, spend forecasts, and performance insights.
Agent reputation and trust scores: Track reliability and success rates to create a trusted economy of agents.
Batch payments: Support group payouts or multi-agent settlements in one transaction.

Nice to Have

Smart contracts and on-chain settlement: Experiment with decentralized clearing and auditable, immutable ledgers.
ML-driven approval models: Use learned behavior to predict or pre-approve low-risk transactions automatically.
Multi-tenancy for organizations: Allow companies to host and govern multiple agent ecosystems securely.
Data exports: Add CSV/PDF reporting for compliance, analytics, and offline review.