Setting up BPaaS Agent

What you choose

Answering you takes three stages, and you pick what handles each one independently:

Speech to text → Assistant (LLM) → Text to speech

Music, Web Search, Calls, Navigation and where Notes are stored are chosen the same way. You are not tied to one vendor: run the assistant locally for privacy while using a cloud voice for quality, or any other combination that suits you.

Everything below lives under the gear icon, top-right. Two status icons at the top of the Voice tab tell you whether you are ready to go:

The green AI icon answers “is a model assigned and valid”, not “will it fit in memory right now”. Those are different questions — see memory limits.

Local engines — llama.cpp, whisper.cpp and OuteTTS

Local engines run entirely on the iPhone. Audio, transcripts and inference never leave the device, and nothing is sent to any provider. They need model files in GGUF format, which you download inside the app.

Downloading a model

1. Open Settings → AI → Local Models.
2. Paste a direct Hugging Face file URL — the kind containing resolve/main/ that points at the .gguf file itself, not the model's web page.
3. Download it, then assign it to a role: Assistant, Speech-to-text, or Text-to-speech.

Only huggingface.co URLs are accepted — the allowlist is enforced at download time, so a link from anywhere else will be refused. Files are stored in the app's own sandbox and tracked in a manifest that survives restarts, and your engine and model choices persist too. You can also import model files through the Files app instead of downloading.

Browse GGUF models on Hugging Face

llama.cpp — the local assistant

Assign a GGUF chat model to the Assistant role, then select llama.cpp (offline) under Settings → AI → Engines. One thing to know before you rely on it: Continuous (streaming) listening turns off while a local assistant is selected, because it processes one request at a time on the device. Auto (loop) listening still works.

whisper.cpp — local speech-to-text

Assign a Whisper GGUF model to the Speech-to-text role and select Whisper.cpp (offline) in the engine list. This is what lets the agent hear you with no network at all.

OuteTTS — local voice (needs two files)

This is the one setup step that catches people out. OuteTTS 0.3 needs two GGUF files, not one:

1. The OuteTTS language model, which generates audio codec tokens.
2. A WavTokenizer, the vocoder that turns those tokens into audio.

Set the OuteTTS model path as the active text-to-speech model. The WavTokenizer file is discovered automatically from the same directory, provided its filename contains wavtokenizer or vocoder. If the voice never produces sound, that filename is the first thing to check. Output is 24 kHz mono audio.

Memory limits — why the app might close by itself

Local models are the largest thing the app ever puts in memory. A recommended assistant model is around 1 GB, plus a few hundred megabytes of working memory while it answers. If the iPhone cannot spare that, iOS terminates the app rather than letting it continue — no crash report, it simply closes, which looks like a bug but is not one.

The app checks before loading and tells you, with the real numbers, if a model will not fit: close other apps, or assign a smaller model. If iOS kills it anyway — another app can claim the memory at any moment — the next launch writes a red entry in Settings → Logs → Engine Calls naming the model and how much memory was free, because an app that has been killed never gets to report it itself.

Cloud providers — API keys

Every credential goes in one place: Settings → Vault → API Keys. They are stored in the iOS Keychain, never in plain text and never in preferences, and requests go straight from your device to that provider. No bpaas.it server sits in between, and we never see your keys.

You only need keys for the engines you actually select. Get each one from the provider, then paste it into the Vault.

A note on cost. Because you bring your own keys, you pay each provider directly for what you use, at their rates. There is no markup from us, and no subscription to BPaaS for the app itself.

Selecting the engines

Once the keys are in the Vault, go to Settings → AI → Engines and pick the active engine for each capability. Where a provider offers several models or voices — OpenAI, Gemini, Claude, ElevenLabs — you choose which on that same screen. The ElevenLabs voice ID goes here rather than in the Vault: it identifies a voice, it is not a secret.

Picking a voice that speaks the language

If you use the interpreter or translated calls, this decides whether the other person can follow you. The app tells the voice which language to speak, but how much notice it takes depends on the engine and, for two of them, on which model you picked:

When the app cannot pass the language on, it says so in Settings → Logs → Engine Calls against that spoken line, with the reason. That is the place to look if something still sounds wrong.

Offline and degraded-network fallbacks

Each capability has its own offline engine choice, and a degraded-network tier, on the same Engines screen. This is what makes a mixed setup worthwhile: run cloud engines normally, and name a local model to take over when the connection goes. If you have a local model assigned, going offline — airplane mode included — no longer produces a connection error; the app answers on your local model instead, from the very first message.

A slow or flaky connection is treated differently on purpose: that still retries the cloud rather than quietly downgrading you.

Navigation and Notes — no keys needed

MCP servers — connecting external tools

Model Context Protocol is an open standard for exposing tools to an assistant. Register an HTTPS MCP server and its operations become things the agent can actually do — “ask the docs server about this repository”, query a database, reach a business system.

How a server authenticates

Six ways, all set up when you add the server or later on its page, where every field stays editable — including the method itself:

Google's MCP servers

Google's servers use OAuth browser sign-in. Google's own documentation is the authority on which server you want and how to create a client — we deliberately do not reproduce those steps, because they change and a stale copy is worse than none:

Google MCP Toolbox documentation Google Cloud Console

Come back with a server URL, an OAuth Client ID, and the scopes that server's documentation asks for. Then:

1. Open Settings → MCP Servers and add a server.
2. Paste the HTTPS server URL and choose OAuth browser sign-in. Picking the Google option fills in the endpoints and the redirect address for you, so the Client ID is all you paste.
3. Add the scopes, separated by spaces. This matters: a provider's default scope only identifies you — reaching a server's tools needs the scopes that server asks for.
4. Add the server, then tap Connect on its page to sign in.

Create an “iOS” OAuth client, not a “Web” one. iOS only lets the sign-in return to a custom address like yourapp:/callback, so a Web client cannot work from a phone. The app tells you so rather than leaving the browser hanging.

The last step for every other server

1. Open Settings → MCP Servers and add a server.
2. Paste the HTTPS server URL and pick the authentication method above.
3. Credentials go straight into the iOS Keychain, are never shown again, are redacted from logs — the sign-in traffic included — and are deleted with the server.
4. The app connects and lists every operation the server offers, and what information each one needs.
5. Enable them one by one. Nothing reaches the assistant until you do.
6. Optionally adjust approval on the server's page, or per individual operation.

What the agent can and cannot do with it

By default every call asks you first, showing exactly what would be sent, and you approve or deny by voice or text. Each server — and each individual operation — can relax or tighten that on its own settings page. Results come back labelled as external data, and the assistant can never approve its own request: only a message from you can. If a server is unreachable, missing a credential, or simply not signed in yet, its operations are not offered at all, rather than failing mid-conversation.

There is also a refreshable catalog repository of suggested MCP servers under the same settings screen. Only allowlisted domains are accepted, a refresh happens only when you tap it, and a fetched catalog can suggest a server — never enable one.

Checking your setup

• The two icons on the Voice tab. AI engine green means all three active engines are ready; WiFi green means you have connectivity.
• Settings → General → Information holds the full how-to, every voice command with a spoken example, and the live engine list — generated from the same catalogs the assistant itself runs on, so it cannot fall out of date.
• Settings → Logs → Engine Calls is where a failure explains itself: model load errors, memory warnings, call lifecycle, and a red entry on the next launch if iOS terminated the app.
• Settings → General → Information → This build shows the exact source commit the installed app came from, so you always know which version you are running.