Perplexity moves its Computer agent onto local NVIDIA hardware

Perplexity has launched Portable Computer, a local-first version of its Computer agent that moves the core agent runtime onto hardware controlled by the user. The first release runs on NVIDIA DGX Spark under Linux and is available to Perplexity Pro and Max subscribers. Unlike a desktop client that still sends most reasoning to the cloud, Portable Computer can run the model, orchestrator, planner, tool router, scheduler, durable task queue and local search index on the device itself.

That makes the launch relevant to engineering teams dealing with private source code, confidential documents or workloads where recurring cloud inference costs matter. According to Perplexity's launch announcement, local work does not consume Perplexity credits, and the system can ask the user for permission before escalating a step to cloud models when stronger reasoning or external information is needed. The important architectural change is therefore not simply "AI on a PC." It is a hybrid agent design that treats local execution as the default boundary and the cloud as an explicit escalation path.

The agent runtime moves onto the workstation

Portable Computer initially supports Qwen 3.8 27B and PPLX 27B, Perplexity's post-trained variant. NVIDIA Nemotron 3.5 Lightning is planned for the model picker. Perplexity says the local model can search files and code, synthesize documents, take actions on the machine and keep longer jobs running, while the orchestration components remain local as well.

NVIDIA's Local AI update independently confirms that Portable Computer is optimized for DGX Spark and is intended to keep private workflows local without counting local work against token limits. DGX Spark is built around NVIDIA's GB10 platform with 128 GB of unified memory, which is a very different hardware target from a conventional office laptop. That matters when evaluating the launch: this is evidence that capable local agents are becoming productized, but it is not evidence that the same workloads are now practical on ordinary developer machines.

Perplexity says RTX GPU PC support is coming and Windows support is planned. Until those arrive, deployment is constrained by Linux and relatively specialized NVIDIA hardware. The product therefore starts closer to a workstation-class agent appliance than a mass-market desktop assistant.

Privacy depends on the routing boundary

The strongest practical argument for local agents is data control. A coding or research agent can be useful precisely because it sees the files, repositories and internal context users do not want copied to an external model provider. Portable Computer is designed so local files and local processing can remain on the device, with cloud escalation requiring authorization.

That is a meaningful control boundary, but it should not be oversold. "Local-first" is not the same as "offline-only." Web research, connected SaaS applications and frontier cloud models necessarily introduce external systems when the user invokes them. Perplexity also says code and tool execution run inside isolated sandbox environments with controlled file and application access. For engineering and security teams, the real evaluation question is whether those controls are observable and enforceable enough for their threat model.

Independent reporting from Computerworld highlighted the same tension. The local design can reduce exposure of sensitive data and lower usage costs, but enterprises still need to verify how the privacy boundary is enforced, what telemetry leaves the device, how cloud escalation is represented to users, and how connector permissions interact with local files.

Local inference changes agent economics

Cloud agents carry two variable costs: model inference and the infrastructure required to keep long-running tasks alive. Portable Computer shifts part of that cost into owned hardware. Perplexity says on-device work consumes no credits, so frequent document analysis, code inspection and routine planning can be handled without metered cloud usage after the hardware and subscription costs are paid.

That does not make the system free. DGX Spark is specialized hardware, Pro or Max access is still required, electricity and maintenance remain real costs, and difficult tasks may still escalate to paid cloud inference. The economic question changes from "how many tokens will this workflow consume?" to "which portion of the workload is cheap enough and capable enough to keep local, and when is cloud intelligence worth invoking?"

Perplexity has published benchmark results claiming that its harness and PPLX 27B configuration outperform alternative local harnesses on several knowledge-work tests. Those are vendor-run evaluations, so they should be treated as attributed evidence rather than an independent performance verdict. The more defensible point is architectural: Perplexity is shipping an integrated agent stack in which local models, persistent task machinery, search and sandboxed tools are packaged together rather than left to developers to assemble.

Why this matters for software teams

For software engineering organizations, Portable Computer is notable because private codebases are one of the explicit workloads Perplexity describes. A local agent that can inspect repositories, search project context and perform tool-driven work without automatically transmitting that context to a remote model changes the trade-off between agent usefulness and source-code exposure.

It also illustrates a broader direction for coding-agent architecture. Many current products centralize orchestration and inference in vendor clouds, even when the user interface runs locally. Portable Computer flips more of that stack onto the workstation while retaining a selective cloud escape hatch. That hybrid model could become useful for teams that want local handling of routine context and sensitive assets but still want access to frontier reasoning for hard steps.

The unresolved questions are operational. Teams should test sandbox escape resistance, network policy, secret handling, audit logs, connector scopes, data retained during cloud escalation, and failure recovery for long-running jobs. They should also measure whether the local 27B-class models are actually sufficient for their codebase and workflow rather than assuming that vendor benchmarks translate directly to software-engineering productivity.

Portable Computer is therefore less important as another AI desktop app than as a concrete packaging of local-first agent infrastructure. It puts model inference, orchestration, memory-like local indexing and tool execution on owned hardware, while making remote models an optional step rather than the default execution environment. If the approach proves reliable beyond DGX Spark, it could make local and hybrid deployment a more realistic architecture choice for organizations that have so far treated advanced agents as cloud-only systems.

Sources
- Perplexity: Introducing Portable Computer
- NVIDIA Local AI: Portable Computer on DGX Spark
- Computerworld: Perplexity's on-device AI offering