SovereignAI

Blog · Guide · August 25, 2026

SovereignAI with Perplexity's Portable Computer: what works today

Perplexity's Portable Computer launched this week as a local-first agent for NVIDIA machines. People with one of those machines asked us the obvious question: can SovereignAI and Portable Computer live on the same box, and can they talk to each other? Yes to the first. The second is more interesting — and this guide draws a hard line between what we have verified, what Perplexity has stated, and what nobody has documented yet.

By the SovereignAI team at Unify Dynamics · about eight minutes · Perplexity's statements come from its announcement, product page, and research post, and NVIDIA's launch post, all read on the date above; we have not run it

Two products, two jobs

Portable Computer is an agent harness: it runs multi-step tasks — research, files, code, connected apps — on a local model, inside an OS-enforced sandbox, and asks before escalating a step to a frontier model in the cloud. SovereignAI is the memory, knowledge, and exit layer: a private AI that knows you over time, records where every fact came from, parses your documents and history on your machine, and exports all of it in a verifiable format. One does tasks; the other holds the reassembled you. They are not substitutes, and on one machine they are not in each other's way — with one exception, the GPU, which we will get to.

What each one needs

Perplexity's published install commands for the Spark (Linux, apt), verbatim from its product page:

sudo curl -fsSL https://packages.perplexity.ai/perplexity.gpg -o /usr/share/keyrings/perplexity.gpg
echo "deb [signed-by=/usr/share/keyrings/perplexity.gpg] https://packages.perplexity.ai/deb stable main" | sudo tee /etc/apt/sources.list.d/perplexity.list
sudo apt-get update
sudo apt-get install perplexity

Living on one machine

verified Nothing about the two conflicts on disk or on the network. Portable Computer's vLLM and SovereignAI's Ollama use different weight formats, so the models are not shared — budget disk for both. Ports do not collide in the default layouts: Ollama on 11434, FreeToken on 1919, SovereignAI on 4321.

verified The GPU is the real constraint — on a Spark today, and on RTX cards once that support ships. A vLLM server pins its model and KV cache in memory for as long as it runs; on a 24 GB card with a 27B model resident there would be little left for a second engine, and even in the Spark's 128 GB pool the two share one budget. Three sane arrangements:

Connecting them

stated, not documented Perplexity's engineers told VentureBeat that Portable Computer has an advanced mode for plugging in your own inference endpoint, and launch coverage summarized it as "bring-your-own model and inference server"; neither the announcement, the product page, nor the research post mentions it. If that endpoint speaks the OpenAI chat-completions protocol — as vLLM, Ollama's /v1 API, and FreeToken all do — then in principle you could serve one model once, through Ollama or FreeToken, and let both products use it. We have not seen the configuration, so we cannot give you the steps, and we will not invent them. When Perplexity documents the setting, this section gets the commands.

stated, not documented The reverse direction: SovereignAI can use any OpenAI-compatible server as a provider — Settings → Providers → OpenAI-compatible, base URL and (optional) key. vLLM's own server exposes such an endpoint by default; whether Portable Computer's embedded vLLM listens on a local port that another program may use is not something Perplexity has published. If it does, adding it as a provider is one form. If it does not, it does not, and no amount of wishful documentation on our side changes that.

verified What you can do today without either of those: use SovereignAI's MCP server and integrations where they are supported — Claude Desktop, Claude Code, Codex CLI, Cursor, Windsurf, Gemini CLI, the editors, the browser. Perplexity says Portable Computer converted MCP servers into compact command-line tools internally; whether users can add their own MCP servers is not stated. So SovereignAI's memory is not reachable from inside Portable Computer today, and this page will say so until it is.

Where the philosophies meet

The part of Portable Computer we admire is the one we adopted: before a step goes to the cloud, show what would leave and ask. Perplexity's research post describes it precisely — the harness selects the context, runs a PII classifier over it, shows the user what would leave, and the user approves each advisor call manually or lets it happen automatically. SovereignAI now does the same for every remote send — the customs declaration — with two differences. We show the bytes without a PII classifier in front of them, because a classifier is another model reading your data; and the declaration is part of a product that also answers the other two questions — can you read every line, can you take everything out and leave. Portable Computer answers neither: the harness is closed, the account is required, the connectors hold your credentials, and nothing in its launch material says where your memory lives or how you export it.

That is not a reason to avoid it. It is the reason to keep the layer that holds you somewhere you own, and let the agent be an agent.

A practical recommendation

We have not run Portable Computer ourselves — it launched today and requires a DGX Spark and a subscription we do not hold. What we have read is Perplexity's announcement, product page, and research post, and NVIDIA's launch post; every statement above is attributed to one of those or, where marked, to an interview in the launch coverage. The two connection paths are marked stated-but-undocumented on purpose. When either becomes verifiable, this guide changes; until then, treat those sections as a map of what to check, not a recipe.

Let the agent be an agent. Own the rest.

The ledger lists exactly which layers SovereignAI holds and which it borrows.

Run it now

Sources