Interface

Autonomous browser automation and AI payments system

Comment

Inspiration

We realized that AI agents are getting incredibly smart, but they're stuck in a read-only world. They can answer questions and generate content, but they can't actually do anything that requires payment. What if your AI assistant could book a flight for you, buy market data, or pay for premium services, all autonomously, with your permission? That's where the MNEE stablecoin comes in, and that's why we built Interface: the coordination layer for the autonomous agent economy.

What it does

Interface is a production-grade SDK and interface that lets AI agents transact autonomously using the MNEE stablecoin on Ethereum. It's not just about LLM conversations, it's about giving agents economic agency.

The system includes:

  • AI-powered chat interface where agents can request payments for premium services
  • Slide-to-Pay authorization UI embedded right in the chat for instant, secure approvals
  • Deterministic browser automation that simulates real-world tasks like flight booking
  • Granular budget controls with per-transaction limits, hourly caps, and total budget enforcement
  • Real-time analytics dashboard showing agent spending, transaction history, and budget usage

Users connect their MetaMask wallet, set a budget, and chat with an AI agent powered by Gemini 2.0 Flash. When the agent needs to access premium services (weather data, stock prices, flight searches), it requests payment through MNEE, and users approve with a single swipe.

How we built it

We built Interface as a modular system with clear separation between reasoning and execution:

Frontend (/dashboard): Built with React, Vite, and TypeScript. We used ethers.js for blockchain interactions with the MNEE contract on Ethereum mainnet (address: 0x8ccedbAe4916b79da7F3F612EfB2EB93A2bFD6cF). The UI features GSAP and Framer Motion animations for a premium feel, and a custom "Slide-to-Pay" component that handles micro-authorizations.

MNEE Backend (/mnee-backend): A Node.js Express server that manages stablecoin balances, logs all transactions to a persistent database, and implements the core "Payment Loop" refund logic to ensure users never lose funds from failed operations.

Intelligence Engine (/api-gateway): A FastAPI-based agent powered by Google's Gemini 2.0 Flash model. The agent has access to three mock premium services:

  • Weather API (0.10 MNEE) - Detailed forecasts
  • Stocks API (0.25 MNEE) - Real-time market data
  • Flights API (0.50 MNEE) - Flight search with AI predictions

Core SDK (/core): Python package implementing AgentEconomyProvider which enforces strict budgetary controls and prevents runaway agent spending.

Challenges we ran into

Wallet integration complexity: Getting MetaMask to work smoothly with our custom payment flow was harder than expected. We had to handle edge cases like wallet disconnections mid-transaction, network switching, and ensuring the MNEE token was properly added to users' wallets.

Agent authorization UX: The biggest challenge was creating an authorization flow that's both secure and frictionless. Traditional payment flows interrupt the conversation. We solved this with an embedded "Slide-to-Pay" component that appears inline in the chat, maintaining conversational flow while ensuring explicit user consent.

Budget enforcement across async operations: With agents making multiple API calls in parallel, we needed rock-solid budget tracking. We implemented a locking mechanism in the AgentEconomyProvider to prevent race conditions and ensure the agent never exceeds its allocated budget even with concurrent requests.

Mock browser automation: Building the FlightBrowserDemo to simulate real-world interactions was tricky. We wanted it to feel authentic, loading states, realistic delays, dynamic pricing, while keeping it deterministic for demo purposes.

Accomplishments that we're proud of

We created a genuinely novel UX pattern for AI agent payments. The "Slide-to-Pay" authorization feels native to chat interfaces and solves a real problem: how do you give agents economic power without sacrificing user control?

The granular economy controls work beautifully. Users can set total budgets, per-transaction maximums, and time-based limits (hourly/daily), giving them precise control over agent spending.

We're proud that Interface is production-ready. It's not just a hackathon demo, it's a fully functional system with proper error handling, transaction logging, refund logic, and a polished dashboard showing real-time analytics.

The multi-currency analytics feature automatically converts between MNEE/ETH and USD across all metrics, making it easy for users to understand costs in familiar terms.

What we learned

Programmable money changes everything: Once you give AI agents the ability to pay for things, entirely new use cases emerge. Agents become genuine assistants that can complete full workflows, not just give advice.

User trust is paramount: People are (rightfully) nervous about giving AI agents access to money. Every design decision had to prioritize transparency, control, and explicit authorization. The slide-to-pay UI and detailed transaction logs were critical for building trust.

The MNEE stablecoin is perfect for this: Using a stablecoin instead of volatile crypto makes the economics predictable and understandable. Users know exactly what they're spending.

Agent reasoning + blockchain execution is powerful: Separating the AI's reasoning (Gemini 2.0) from the payment execution (MNEE/Ethereum) creates a robust system where each component does what it's best at.

What's next for Interface

Expand the service catalog: Right now we have three mock services. We want to integrate real APIs web search, data analysis, code execution platforms, cloud compute, creating a true marketplace where agents can autonomously purchase services.

Multi-agent coordination: Enable multiple agents to pool budgets and work together on complex tasks, splitting costs and coordinating payments.

Recurring subscriptions: Allow agents to manage ongoing subscriptions autonomously, deciding when to renew based on usage patterns and budget availability.

Cross-chain support: Expand beyond Ethereum to support MNEE on other chains, giving agents access to a broader ecosystem of services.

Agent-to-agent payments: Let agents pay each other for services, creating a true autonomous economy where specialized agents can monetize their capabilities.

Smart refund policies: Implement automated refund logic for failed services, partial completions, and unsatisfactory results, making the system more resilient and user-friendly.

Built With

Share this project:

Updates