An open-source answer to Perplexity's Portable Computer

Portable Computer is the local build of Perplexity Computer, the hosted agent Perplexity ships as a general-purpose digital worker. Its help center states the job in one line: "Portable Computer runs Perplexity Computer's model and agent on your own hardware, so tasks execute on your device instead of in the cloud" (What is Portable Computer?, checked October 2026).

The local half is substantial rather than a thin client. Perplexity lists five pieces that run on the device:

• the model that does the orchestrating
• the planner, plus the router that picks tools
• the scheduler and a queue that survives restarts
• an index of your own files and code
• a sandbox around code and tool execution

Because the orchestrator sits on the machine, a task can start, plan, read local files, run tools and finish without a round trip to Perplexity's servers. Files, queries and agent activity stay put unless you approve a step that leaves.

The floor is a 24 GB one. You need an NVIDIA DGX Spark, or a Windows or Linux PC with a supported NVIDIA GeForce RTX or RTX PRO GPU of 24 GB of VRAM or more, or a Windows PC with an AMD Ryzen AI Max Series processor and 24 GB of GPU-accessible memory. A DGX Spark meets the bar on its own. The operating system must be Windows 10, Windows 11, Ubuntu or DGX OS. A card that reports less than 24 GB hides the on-device models, and the Local Inference screen shows a notice instead (Perplexity's product page, checked October 2026).

The plan floor arrives with it. Portable Computer is available to Pro and Max subscribers, on a personal or an Enterprise plan. Perplexity's pricing page lists Pro at $17 a month on annual billing and Max at $167, with Free limited to search (checked October 2026). The local lineup splits by platform. PPLX 27B and Qwen 3.8 27B run on a DGX Spark; Windows and Linux RTX PCs get PPLX 27B, and Qwen 3.8 27B is not available on Linux RTX PCs. NVIDIA Nemotron 3.5 Lightning shows in the picker as coming soon, and only one model loads at a time.

Long work stops metering. Work the local model handles consumes no Computer credits. A recurring job uses the local scheduler and durable task queue. A daily pull-request review or a weekly summary of local files then runs on hardware you already paid for. Local MCP servers extend that: the agent can drive tools installed on your machine, which cloud Computer does not do.

Two limits ride along. Brain, Perplexity's saved memory, is unavailable in local mode, so the agent on your GPU arrives without the memory the cloud version keeps. The local model is also smaller than a frontier model. A step that needs the open web or frontier reasoning asks permission first, and the cloud meters it. Connectors reach Gmail, Outlook, OneDrive, Word, Google Drive, Slack and GitHub through the local orchestrator, against 400+ app connectors in the cloud product.

Hardware does not buy out the subscription. Put a 24 GB card or a DGX Spark on the desk and the monthly line stays. Only the credit meter drops, and only for the work the local model finishes. Teams that already own an RTX workstation come out ahead on escalated work. Anyone buying a machine for this pays the larger number first, and it depreciates while the plan renews.

Less than it sounds. A local Perplexity installation keeps its value in the app and in Perplexity's cloud, so the only things that travel are the outputs you already have: documents, spreadsheets, drafts, a few exports. Nobody has to migrate a runtime.

A Kortix project has the opposite shape. The repo carries the prompts, the skill files, the connector grants and the model choice, which means the setup one person builds on a laptop is the setup a colleague clones on a server. You can try a new instruction on a session branch, compare what the agent returns against the version on the default branch, and undo a bad week by reverting a commit.

The trade is real in both directions. Perplexity's local build hands you a model picker, a scheduler and a settings screen, and any of the three changes with a click and leaves no trace. Kortix asks you to keep the definition of the work in a file, which is more discipline up front and a better answer six months later when someone asks what the agent was told to do.

Three checks save an expensive mistake. First, the memory number is graphics memory, not system memory, so a workstation with 64 GB of RAM and a 12 GB card still falls short. Second, the supported list is short on purpose: Windows 10, Windows 11, Ubuntu and DGX OS, with no macOS entry anywhere in the requirements table, because a Mac runs a local model through Personal Computer instead. Third, the plan is the gate. A supported card in a machine with no Pro or Max subscription runs Perplexity in the cloud and never lights up the local models.

If all three hold, the setup is quick. Download the model from Local Inference in the app on Windows, or install the package on Ubuntu, pick the local model in the composer, and the next task runs on your desk.

If the card falls short, no setting rescues it. Perplexity hides the on-device models, shows a notice on the Local Inference screen and points you at Computer in the cloud, so the answer is different silicon or a different approach.

One more thing to price before the card ships: disk. The app needs about 19.6 GB for the first Windows download and another 19.9 GB for the second model, while a DGX Spark setup starts near 38.6 GB, and updates want the new model's size plus roughly 5 GB of headroom. On a laptop already carrying a few years of projects, that is the number that decides which machine gets the install.

Ownership is the question local mode leaves open. Perplexity moved the runtime onto your silicon and kept the agent's definition, its memory and its connector setup inside its product. Kortix is open source, and it ships those pieces as files instead, so the whole arrangement reads, diffs and travels like code.

An agent is one markdown file for behavior and one block of the project manifest for its grants. The markdown holds the prompt and the tool rules; the manifest decides which connectors, secrets and skills the agent may reach. Where it runs is a setting too: on a Linux server with Docker, in a VPC, or on Kortix Cloud.

The documented install is three commands on a Linux server, and none of them looks for a GPU:

curl -fsSL https://kortix.com/install | bashkortix self-host init --domain kortix.example.com --admin-email you@example.comkortix self-host start

The self-hosting docs list what the stack runs and what it needs: a server with a public address, DNS records, ports 80 and 443, and a key for a sandbox provider. Sessions run on that provider, not on the server. Models are your choice too, billed to whichever provider you key.