The AI workbench you own: local models, cloud specialists, private context, and tools in one iOS home.
AI is becoming too important to live inside one company's box.
The best model for a job might be local. The next one might be OpenAI, Anthropic, Gemini, OpenRouter, or an OpenAI-compatible endpoint you run yourself. Your notes might belong in a private vault. Your tools might come from MCP servers. Your phone might be powerful enough to do more than forward every thought to somebody else's cloud.
Pines is built for that future.
Not a chatbot. Not a single-vendor wrapper. Not a toy demo of "AI on mobile." Pines is a workbench for choosing the right intelligence for the moment, keeping sensitive context close, and letting local and cloud models cooperate without making you surrender the whole room.
It is for new AI users who want one clear place to start. It is for power users who already know no single model wins every task. It is for people watching local mobile AI become real and thinking: good, now give me an app that treats it seriously.
Pines gives you a center of gravity.
Local MLX models can live on device. BYOK cloud providers can be added when you want outside reach. OpenAI, OpenAI-compatible services, OpenRouter, Anthropic, and Gemini can sit beside local inference instead of replacing it. The point is not to pick a religion. The point is to pick the right route.
Ask a small local model to work through private notes. Bring in a stronger remote model when the job needs more reach. Keep vendor choice open. Keep the boundary visible.
That is the promise: multi-vendor AI without turning your workflow into a pile of tabs, keys, pasted files, and half-remembered settings.
Pines treats the major cloud providers as specialists with visible capabilities, not interchangeable text boxes.
OpenAI uses official Responses features for reasoning controls, native web search, attachments, and state when those paths are needed, and Pines tracks OpenAI files, vector stores, batches, Deep Research, realtime/session records, and generated artifacts as provider resources. Anthropic brings Claude Messages, prompt caching, thinking controls, citations, hosted files, web search/fetch, batches, token counting, and provider-hosted tool provenance. Gemini brings Generate Content, Interactions, Google Search grounding, URL context metadata, Files API media flows, context caches, Live session records, Deep Research, generated media records, batches, and token counting.
Provider-hosted files, vector stores, caches, batches, research runs, live sessions, generated artifacts, citations, and hosted tool calls are shown as provider resources. They are not confused with your local Vault, and they carry the same local-first rule: use cloud when you choose it, show what left the device, and keep deletion/import paths explicit.
Phones are becoming AI machines in their own right. Pines takes that seriously.
A local model is not just a privacy checkbox. It is instant access. It is work that can happen close to your files. It is a way to ask ordinary questions without making every thought a network request. It is the beginning of a personal AI stack that lives where you already work.
Pines is built around MLX Swift, model discovery, install flows, runtime guardrails, and a vault that can make your own material useful to the model. The goal is simple: make local mobile AI feel less like a benchmark and more like a daily instrument.
Most AI workflows treat context like disposable paste.
Copy this note. Upload that PDF. Drag the same screenshot again. Re-explain the project. Hope the app remembers enough and forgets the right things.
Pines gives context a place to live.
The vault is for the files, notes, chunks, and retrieval that make an assistant actually useful. Attach images, PDFs, Markdown, JSON, CSV, or plain text. Pull private material into a conversation when it belongs there. Keep it local by default. Decide when cloud models are allowed to see it.
This is where Pines starts to feel less like "chat" and more like a personal working environment.
The next wave of AI will not just answer. It will search, inspect, browse, call tools, use prompts, read resources, and cooperate with external systems.
That power needs a handle.
Pines is built with policy-gated tools, agent flows, browser actions, Brave Search BYOK support, and MCP Streamable HTTP. MCP servers can bring tools, resources, prompts, subscriptions, and sampling into the workspace. But the important part is not the acronym. The important part is consent you can see.
If something wants private context, network access, or an action with consequences, Pines is designed around making that moment legible.
You should not need a vendor map, a model leaderboard, and a pile of API dashboards just to start thinking with AI.
Pines aims to make the first step simple: open a conversation, bring in the material, choose the level of power you need, and keep moving. Local when local is enough. Cloud when cloud earns the trip. Tools when they add leverage.
The app should feel calm because the decisions are clear.
If you are already comparing models, providers, context windows, local runtimes, retrieval quality, tool protocols, and privacy boundaries, Pines is meant to meet you there.
It gives those choices a single surface. It keeps local and remote routes in conversation. It treats BYOK as normal, not exotic. It makes MCP a first-class direction instead of an afterthought. It gives the iOS device a real role in the AI stack.
This is the future Pines is pushing toward: a pocket-sized control room for personal intelligence, where no single vendor owns the workflow and no invisible fallback decides what leaves your device.
- Your AI stack should be portable across models and providers.
- Local inference should be a first-class path, not a novelty.
- Cloud should be powerful, optional, and explicit.
- Private context should have a home before it has a destination.
- Tools should be useful without becoming hidden side doors.
- A mobile AI app should feel like an instrument, not a remote control.
Pines is source-available. If you want to build it, audit it, understand the architecture, or work on the internals, start with the Developer README.
Useful field notes:
Pines is source-available under the PolyForm Noncommercial License 1.0.0 (PolyForm-Noncommercial-1.0.0). Commercial use requires a separate written license from RNT56.
Redistributions must preserve the required notices in NOTICE. Third-party dependencies keep their own licenses; see THIRD_PARTY_NOTICES.md.