AuraNode AI
One iOS workspace for choosing, using, and managing multiple AI models without juggling separate apps, histories, and subscriptions.
- AI
- Mobile
- Multi-model
Context
The AI product landscape is powerful but fragmented. Each provider arrives with its own interface, account, model catalogue, conversation history, document workflow, and subscription relationship.
AuraNode was built as a native iOS product that brings those capabilities into one coherent workspace. The project covers the entire delivery path—from product framing and Flutter interface architecture to edge services, model routing, and live subscription access.
The problem
People who use AI for different kinds of work often move between several apps to reach the right model. That breaks context, duplicates subscriptions, and makes generated text, images, and documents harder to find later.
The technical version of the same problem is provider fragmentation. Different APIs, model identifiers, response formats, and commercial rules can quickly leak into the product experience, leaving the mobile client brittle and difficult to evolve.
Product strategy
The strategy was to make model choice available without making it the burden of every interaction. AuraNode treats providers as interchangeable capabilities behind one consistent product language, while still giving advanced users control when they want it.
One workspace
Keep conversations, documents, generated media, and account state together so users can continue work instead of reconstructing it.
Choice with guidance
Expose a clear model catalogue and an automatic path, balancing expert control with a useful default for everyday prompts.
A neutral backend
Keep provider credentials, routing logic, and commercial access behind a stable edge API rather than embedding them in the iOS client.
AuraNode turns that strategy into one native workspace with a provider-neutral backend.
Multi-model conversations
Browse available models, compare their roles, select one directly, or use automatic selection before starting a streamed conversation.
Unified creation
Move between chat, image generation, and document-oriented work inside one product vocabulary and one organized library.
Persistent personal workspace
Keep conversation and generated-output context available across sessions instead of scattering work across independent provider apps.
Subscription-aware access
Connect iOS purchases and product entitlements to backend access rules through RevenueCat without coupling commerce to model routing.
System architecture
A thin mobile client talks to one controlled edge boundary. From there, requests move through a model-neutral gateway to the selected provider, while state and entitlements remain independent supporting systems.
Flutter iOS application
Riverpod coordinates interface state, model selection, conversations, document inputs, and the streamed response experience on-device.
- Flutter
- Riverpod
- iOS
Cloudflare Workers
The Worker is the public backend boundary: it validates app requests, applies product rules, coordinates supporting services, and relays streaming AI responses.
- Workers
- Edge runtime
- Streaming
Vercel AI Gateway
A shared gateway keeps provider-specific access out of the client and gives the backend one route for invoking different model families.
- AI Gateway
- Unified API
- Routing
Model providers
The selected provider performs inference and returns tokens through the gateway and Worker to the active conversation in the app.
- Multi-provider
- Text
- Media
Redis
Supports low-latency server-side state and request coordination without coupling that responsibility to any model provider.
Supabase
Provides the durable application data layer behind the Worker boundary, separate from temporary request coordination.
RevenueCat
Keeps App Store purchase state and subscription entitlements separate from the AI request path, so access rules can evolve independently.
Request lifecycle
The iOS client sends a model choice, conversation context, and user input to the Cloudflare Worker. The Worker acts as the trusted service boundary and forwards the normalized request through Vercel AI Gateway. The selected model provider performs inference; the response then streams back through the same route so the interface can render output progressively.
Separation of concerns
Redis supports fast-changing server state, Supabase holds durable application data, and RevenueCat owns subscription truth. Keeping those responsibilities outside the inference chain prevents provider changes from leaking into the mobile interface and keeps commercial access independent from a specific model vendor.
Key experiences
The interface gives model choice real depth, then gets out of the way once the user begins working.
Fast onboarding
A concise first-run path explains the unified value proposition and takes users directly into the assistant without a long setup ritual.
Model discovery
Search, provider filters, capability context, and pricing cues turn a dense model catalogue into a decision users can make with confidence.
Focused conversation
Streaming responses, model context, and compact input controls preserve momentum while keeping advanced options close at hand.
Aura Gallery
Images and documents live in a dedicated library, making generated work retrievable after the conversation that produced it has ended.
Engineering decisions
Riverpod for explicit client state
Feature state stays predictable across model discovery, active conversations, generated assets, and subscription changes.
Workers as the security and streaming boundary
Provider credentials and backend rules remain off-device while the edge runtime keeps the request path close to users.
Gateway-first model integration
Vercel AI Gateway gives the backend a stable model-access layer, reducing provider-specific logic in the mobile application.
Redis for low-latency coordination
Fast-changing state can be handled independently from the client and inference providers, keeping the architecture composable.
RevenueCat for subscription lifecycle
App Store purchases, renewals, and entitlements are handled by a service designed for mobile commerce rather than custom billing code.
Shipped, not simulated.
AuraNode has been published on the iOS App Store with live subscriptions. It demonstrates delivery across product strategy, native mobile UX, edge architecture, multi-provider AI integration, and monetisation as one working system.
No speculative performance or growth metrics are presented here; the proof is the shipped product and its operational subscription flow.
- Native Flutter iOS application completed
- Multi-model AI request path connected through an edge backend
- Live RevenueCat subscription access integrated
- Source reference available on GitHub