Perplexity Portable Computer: Local AI Agents on DGX Spark

Perplexity shipped something unusual: a fully local version of its agentic Computer platform that runs the entire stack — orchestrator, subagent, inference engine, tools, and sandbox — on your own hardware. No cloud dependency by default. No per-token billing for local work. The product is called Portable Computer, and it runs on NVIDIA DGX Spark and Linux machines with RTX GPUs. If you are building agentic systems, this pairs well with our earlier look at the DeepSeek Harness open-source agent framework.

The model, the files, and the work all stay on the device. When a task needs frontier reasoning or live web access, the system stops and asks before routing that single step to one of 15+ cloud models. Sensitive data never leaves without explicit permission.

What Ships

Portable Computer is not a local chat app with a file picker. It bundles:

• Local model — Qwen 3.8 27B or PPLX 27B (Perplexity's post-trained variant)
• Inference engine — vLLM underneath, optimized for DGX Spark
• Agent harness — orchestrator, planner, tool router
• Tool sandbox — OS-enforced, restricts filesystem, process, and network access
• App connectors — Google Drive, Gmail, Slack, GitHub, Outlook

NVIDIA Nemotron 3.5 Lightning (30B MoE) is listed as coming soon. Bring-your-own model and custom inference server are also supported.

# Installation on DGX Spark — standard apt repository
sudo apt update
sudo apt install perplexity-portable

# First run downloads the selected model (17–19 GB)
portable-computer --model qwen-3.8-27b

The Qwen 3.8 27B model ships at 3-bit quantization (17.4 GB download, requires 32 GB RAM). The PPLX 27B variant uses the same base but is post-trained specifically for Perplexity's harness.

The Local-First Architecture

The key design decision is that every task starts on-device. The orchestrator LLM plans the work, the subagent LLM executes it, and all tool calls run inside an OS-enforced sandbox. If the sandbox is unavailable, tool execution is disabled rather than silently downgraded.

When a step needs more than the local model can handle — complex reasoning, live web search, or a task requiring a frontier model — the orchestrator pauses. It selects the relevant context, runs a PII classifier over it, and shows the user exactly what would leave the device. Only after explicit approval does the step route to a cloud model, which returns text guidance and never receives direct access to local files, tools, or conversation history.

# Conceptual flow of Portable Computer's local-first orchestrator
from portable_computer import Orchestrator, Sandbox

orchestrator = Orchestrator(
    local_model="qwen-3.8-27b",
    sandbox=Sandbox(
        filesystem="/home/user/projects",
        network=False,           # no outbound by default
        process_limit=16,
    ),
    escalation="ask_first",     # ask user before cloud routing
    pii_check=True,             # scan context before sending out
)

# All work runs locally unless escalation is approved
result = orchestrator.run("Analyze the financial docs in ~/Documents/1099/")
# If the task exceeds local capabilities:
#   -> PII scan -> user approval -> route to frontier model -> text-only response

Benchmark Numbers

Perplexity ran its own evaluation on a 53-task Local Knowledge Work Bench spanning deep research, financial analysis, and document creation. The company says it plans to open-source the benchmark.

Portable Computer achieved the highest accuracy while using the fewest tokens. Pi completed tasks fastest but with lower accuracy and higher token consumption.

On Terminal Bench 2.1 (code-heavy tasks), the fully local run scored 59.6% at effectively zero marginal cost. With cloud escalation, it reached 73.0% at roughly $0.415 per rollout, compared to 82.4% at about $0.65 for Claude Opus 5 alone.

Hardware Requirements

The minimum spec is an RTX GPU with 24 GB of VRAM — roughly a GeForce RTX 3090 or newer. DGX Spark is the primary platform, with its GB10 Grace Blackwell superchip, 128 GB unified memory, and 140W TDP.

Nvidia showed that connecting two Sparks over shared memory can run frontier-class open models like DeepSeek's latest, and four Sparks can handle GLM 5.2 or Nemotron Ultra. Eight connected Sparks have been demonstrated internally.

Linux is the only supported OS at launch. Windows support follows in September. Apple Silicon is not on the roadmap — Perplexity says it is focused on Nvidia hardware.

Why It Matters

The economics are straightforward. Local inference carries zero per-token cost. For tasks that iterate over many tokens — repo-scale code migrations, long verification loops, document analysis across hundreds of files — running on owned hardware eliminates the billing problem entirely.

The privacy angle is equally direct. Financial documents, legal files, medical records — the kinds of data people hesitate to upload to cloud services — stay on the device. The PII classifier and explicit escalation gate mean sensitive context only leaves when the user says so.

Perplexity VP of Engineering Nate described the product as bringing "the exact same UI to a fully local app." The interface element that normally displays cloud credit usage "is just parked at zero, because all of this is happening on the device."

The Honest Limits

The benchmarks come from Perplexity's own evaluations. The company acknowledges that compact 27B models still trail frontier models meaningfully on hard reasoning tasks. Cloud escalation "narrows but does not fully close the gap."

The 24 GB VRAM floor excludes the vast majority of consumer PCs. Single Spark clustering is not shipped — it is on the roadmap. And the gap between 59.6% local and 82.4% cloud on Terminal Bench 2.1 is real.

But the direction is clear. Open-source models are improving fast — NVIDIA Nemotron 3.5 Lightning (30B), Qwen 3.6 (35B), and Qwen 3.8 (27B) all punch above their weight on agentic tasks. DGX Spark gives them a home. Portable Computer gives them a harness that actually works.

For developers who want to run agentic workflows without metering every token, this is the most complete local stack available today. Not a preview binary — shipping software, on shipping hardware, with a clear path to larger models as they fit in the memory envelope.