Wat is de Perplexity Portable Computer? Hoe local-first-AI-agents je werk op je pc houden

Perplexity Portable Computer is minder belangrijk omdat het lokaal een 27B-model kan draaien, en belangrijker omdat het de agentruntime zelf naar de machine van de gebruiker verplaatst. Perplexity zegt dat de orkestrator, planner, toolrouter, planneringsfunctie, permanente taakwachtrij en lokale zoekindex allemaal op het apparaat draaien. De agent kan lokale bestanden lezen, documenten en code doorzoeken, acties op de computer uitvoeren en langdurige taken actief houden zonder een cloudmodel als standaardbesturingslaag te gebruiken.

Dat verandert de vraag rond lokale AI. In plaats van alleen te vragen of een model in het RAM of VRAM past, wordt de belangrijkere vraag waar de bestanden, zoekindex, taakstatus, tools, machtigingen en werkomgeving van de agent moeten worden opgeslagen. Portable Computer is ook local-first in plaats van local-only: het kan toestemming vragen om webzoekopdrachten, verbonden apps of geavanceerde cloudmodellen te gebruiken wanneer een taak mogelijkheden vereist die de lokale stack niet kan bieden. Het resultaat is een bruikbaar blauwdruk voor een hybride AI-architectuur waarin de gebruiker eigenaar is van de permanente lokale laag, terwijl cloudintelligentie een optionele hulpbron wordt.

Wat is Perplexity Portable Computer?

Perplexity Portable Computer is een local-first-versie van Perplexity Computer die op 25 augustus 2026 werd geïntroduceerd. In plaats van elke taak via een gehoste agentruntime te sturen, draait het de kern van het agentsysteem op een lokale machine.

In de officiële aankondiging van Portable Computer beschrijft Perplexity een systeem dat lokale gegevens kan analyseren, bestanden kan samenvoegen, workflows kan uitvoeren, lokale inhoud kan doorzoeken en acties op het apparaat kan uitvoeren zonder clouduitvoering als standaard in te stellen.

Het onderscheid wordt duidelijker door het model te scheiden van de agent eromheen.

De bepalende verandering is dus niet simpelweg dat één LLM van een server naar een desktop is verhuisd. De orkestratielaag is mee verhuisd.

Daardoor wordt Portable Computer meer een lokale agentomgeving dan een conventionele lokale chatbot.

Wat draait er daadwerkelijk lokaal in Portable Computer?

Perplexity benoemt expliciet zes belangrijke componenten die lokaal op het apparaat draaien: de orkestrator, planner, toolrouter, planneringsfunctie, permanente taakwachtrij en lokale zoekindex. Die componenten zijn belangrijk omdat een agent veel meer doet dan alleen de volgende token genereren.

De orchestrator bepaalt hoe de algehele taak moet verlopen. Als een gebruiker de agent vraagt een map met rapporten te beoordelen, deze te vergelijken met projectnotities, een uitvoer voor te bereiden en later een samenvatting te versturen, kunnen er tussen het verzoek en het resultaat veel afzonderlijke bewerkingen plaatsvinden.

De planner splitst die taak op in beheersbare stappen. De toolrouter bepaalt of een stap bestandstoegang, lokaal zoeken, code-uitvoering, een applicatiekoppeling of een andere mogelijkheid vereist. De scheduler bepaalt wanneer taken moeten worden uitgevoerd, terwijl de duurzame takenwachtrij ervoor zorgt dat langer durend werk ergens kan worden bewaard, in plaats van ervan uit te gaan dat elke taak eindigt met één chatantwoord.

Dit is het belangrijkste verschil tussen een agent en een chatbot. Een chatbot kan wachten op het volgende bericht van de gebruiker. Een agent kan nog steeds bestanden verwerken, wachten tot een andere actie is voltooid, een mislukte toolaanroep opnieuw proberen of later terugkeren naar een taak.

Portable Computer ondersteunt momenteel Qwen3.8-27B en Perplexity's PPLX 27B op de hardware bij de lancering. Lezers die specifiek geïnteresseerd zijn in de geheugenvereisten van het onderliggende Qwen-model kunnen onze handleiding gebruiken voor het lokaal uitvoeren van Qwen3.8-27B op consumentenhardware.

Maar het model is slechts één verwisselbare component. Het belangrijkere architecturale idee is dat planning, routering, zoeken, taakpersistentie en lokale acties niet langer naast een cloudmodel hoeven te functioneren.

Hoe bepaalt Portable Computer wanneer het de cloud gebruikt?

Portable Computer werkt primair lokaal, maar is niet noodzakelijkerwijs uitsluitend offline. Dat onderscheid is essentieel om het product correct te begrijpen.

Perplexity zegt dat het lokale model is getraind om een taak zo veel mogelijk lokaal te voltooien. Wanneer een taak iets vereist waarover het apparaat niet beschikt, zoals actuele webinformatie, browsertoegang, een verbonden applicatie of geavanceerdere redeneermogelijkheden, kan de lokale orchestrator dat deel van de workflow escaleren.

Een vereenvoudigd beslispad ziet er als volgt uit:

Taak van de gebruiker
   |
   v
Lokale orchestrator
   |
   +-- Kunnen het lokale model en de lokale tools dit voltooien?
   |        |
   |        +-- Ja --> Lokaal voltooien
   |
   +-- Nee
          |
          +-- Actuele webinformatie nodig?
          +-- Verbonden applicatie nodig?
          +-- Browseractie nodig?
          +-- Geavanceerde redeneermogelijkheden nodig?
                    |
                    v
             Toestemming vragen
                    |
                    v
          Goedgekeurde cloudfunctionaliteit gebruiken
                    |
                    v
          Resultaat terugsturen naar lokale workflow

Perplexity zegt dat Portable Computer indien nodig toegang heeft tot de zoekmogelijkheden, brede of diepgaande onderzoeksfuncties, verbonden apps en meer dan 15 toonaangevende modellen. Het zegt ook dat het systeem de gebruiker eerst om toestemming vraagt wanneer inhoud van het apparaat naar een clouddienst moet worden verzonden.

Dit leidt tot een heel andere verhouding tot cloud-AI.

De cloud wordt een mogelijkheid waar de agent om kan vragen, in plaats van de omgeving waarin de agent permanent opereert.

Dat hybride model is bijzonder nuttig voor privéwerk. Een lokale agent kan vertrouwelijke documenten op het apparaat analyseren, maar toch een clouddienst voor zoekopdrachten raadplegen voor actuele marktinformatie waarvoor het niet nodig is om het vertrouwelijke bronmateriaal zelf te versturen.

Hoe gebruikt Portable Computer lokale bestanden en zoekfunctie?

Een nuttige privé-AI-agent hoeft niet elk document in het contextvenster van het model te proppen. Hij heeft gecontroleerde toegang tot bestanden nodig, plus een manier om relevante informatie te vinden wanneer een taak daarom vraagt.

Portable Computer kan lokale bestanden lezen en zoeken in documenten en code. De lokale zoekindex blijft ook op het apparaat staan. Die scheiding is belangrijk, omdat lokale AI veel nuttiger wordt zodra privégegevens als een persistente kennislaag worden behandeld, in plaats van als iets dat voor elk gesprek handmatig moet worden geüpload.

Een vereenvoudigde lokale kennisworkflow ziet er als volgt uit:

Lokale bestanden
    |
    v
Lokale zoekfunctie / index
    |
    v
Relevante documenten
    |
    v
Lokale agent
    |
    v
Modelcontext
    |
    v
Antwoord / Actie / Uitvoer

Het model hoeft dus niet een volledig bestandssysteem te 'onthouden'. Het kan de bestanden of tekstpassages ophalen die relevant zijn voor de huidige taak.

Dit hangt nauw samen met de architectuur die we gebruiken bij het bespreken van het scheiden van lokale AI-berekeningen en langdurige NAS-opslag. De computermachine verwerkt actieve inferentie en agenttaken, terwijl persistente documenten, embeddings, uitvoer en back-ups kunnen worden opgeslagen op een opslaglaag die ontworpen is om jarenlang beschikbaar te blijven.

Het onderscheid wordt belangrijker naarmate agents hun eigen artefacten genereren. Een volwassen workflow kan brondocumenten, embeddings, codeopslagplaatsen, uitvoerbestanden, taaklogboeken, rapporten, afbeeldingsassets, transcripties en snapshots bevatten. Het AI-model is niet langer het enige dat opslag nodig heeft.

Waar bevindt het geheugen van agents zich in een lokaal systeem?

Doorzoekbare bestanden zijn één vorm van persistente context, maar langdurig draaiende agents hebben uiteindelijk iets nodig dat meer op geheugen lijkt: gegevens over eerder werk, projectgeschiedenis, notities, ontdekkingen, beslissingen en de taakstatus, die ook na één prompt behouden blijven.

De lancering van Portable Computer bevestigt al lokale zoekfunctie en een duurzame takenwachtrij, maar het is belangrijk om niet te beweren dat elk onderdeel van Perplexity's bredere geheugenarchitectuur eenvoudigweg naar de DGX Spark is verplaatst.

Daarnaast heeft Perplexity gedetailleerd werk gepubliceerd over de architectuur van zijn agentgeheugen, genaamd Brain. Dat systeem is nuttig om te begrijpen welke richting het bredere denken van het bedrijf opgaat.

Brain behandelt persistente agentcontext als een bestandssysteem in plaats van te proberen de volledige geschiedenis van een gebruiker in elke prompt te forceren. De geheugenstructuur omvat:

De bredere les is belangrijker dan de exacte mapstructuur: agentgeheugen wordt duurzame data.

Modellen kunnen worden geüpgraded. Een lokaal Qwen-model kan zes maanden later worden vervangen door een ander open model. De GPU kan worden vervangen. Zelfs het agentframework kan veranderen. Maar projectdocumenten, taakgeschiedenis, aangeleerde context, geïndexeerde bestanden en eerdere uitvoer moeten al die veranderingen mogelijk overleven.

Daardoor wordt de persistente gegevenslaag steeds belangrijker in lokale AI-architectuur.

Hoe houdt Portable Computer lokale agentacties veiliger?

Een agent lokaal uitvoeren maakt hem niet automatisch veilig. Een capabele lokale agent heeft mogelijk juist toegang tot meer nuttige — en daardoor gevaarlijkere — bronnen dan een eenvoudige chatbot in de cloud.

Een agent die bestanden kan lezen, tools kan uitvoeren, code kan bewerken, applicaties kan aanroepen of opdrachten kan uitvoeren, heeft grenzen nodig rond wat hij mag benaderen. Perplexity zegt dat code- en tooluitvoering in Portable Computer plaatsvindt in geïsoleerde sandboxomgevingen met gecontroleerde toegang tot bestanden en verbonden apps.

Een praktisch beveiligingsmodel voor lokale agents heeft meerdere lagen nodig:

Het veiligste patroon is over het algemeen om agents ruime mogelijkheden te geven om te analyseren en beperktere bevoegdheden om te handelen. We hanteren hetzelfde principe in onze gids voor het gebruik van goedkeuringspoorten voor lokale AI-agents: concepten, samenvattingen, monitoring en aanbevelingen kunnen vaak automatisch worden uitgevoerd, terwijl het verwijderen van bestanden, versturen van berichten, doen van aankopen of wijzigen van rechten om strengere bevestiging vraagt.

Perplexity's bredere onderzoek naar langdurig draaiende agentsandboxes verklaart ook waarom agentuitvoeringsomgevingen verschillen van gewone kortstondige containerjobs. Een agent kan gedurende uren of dagen een werkbestandssysteem, draaiende processen en status opbouwen, waardoor zowel isolatie als herstel belangrijk zijn.

Dat onderzoek moet niet worden opgevat als bewijs dat elk afzonderlijk implementatiedetail van de cloud-SPACE op Portable Computer identiek wordt gereproduceerd. Het laat wel zien welk infrastructuurprobleem lokale agents steeds vaker moeten oplossen: krachtige uitvoering moet samengaan met gecontroleerde toegang en persistente status.

Welke hardware heeft Perplexity Portable Computer nodig?

Bij de lancering is Portable Computer beschikbaar op de NVIDIA DGX Spark voor Perplexity Pro- en Max-abonnees. De eerste release ondersteunt Linux; ondersteuning voor Windows is later aangekondigd. Perplexity zegt ook dat ondersteuning voor NVIDIA RTX GPU-pc's eraan komt.

De DGX Spark is gebaseerd op NVIDIA's Grace Blackwell GB10-platform met een 20-core Arm-CPU, NVIDIA-GPU en 128GB uniform geheugen. Dankzij die grote gedeelde geheugenpool is het systeem geschikt voor het draaien van omvangrijke lokale modellen, terwijl er capaciteit overblijft voor de agentruntime en andere workloads.

Portable Computer biedt momenteel Qwen3.8-27B en PPLX 27B aan, een door Perplexity verder getrainde versie van het Qwen-model. NVIDIA Nemotron 3.5 Lightning staat ook vermeld als binnenkort beschikbaar in de modelkiezer.

Dit betekent niet dat een DGX Spark een universele minimale hardwarevereiste is voor het onderliggende 27B-model. Qwen3.8-27B zelf kan bij kwantisering op aanzienlijk conventionelere hardware draaien. Het 128GB-systeem geeft Perplexity de ruimte om een geïntegreerde lokale agentomgeving te bieden, in plaats van alleen te demonstreren dat het basismodel tokens kan genereren.

Verlaagt AI die lokaal op de eerste plaats komt de cloudkosten echt?

Perplexity zegt dat werk dat door het lokale model van Portable Computer wordt uitgevoerd geen credits verbruikt. Dat verandert de economische aspecten van agentworkloads, omdat agents veel meer inferentie kunnen gebruiken dan gewone chats.

Eén chatbotvraag kan één prompt en één antwoord omvatten. Een agent kan daarentegen:

een taak plannen, bestanden inspecteren, tools aanroepen, een resultaat evalueren, een mislukte actie opnieuw proberen, aanvullende informatie onderzoeken, een andere worker aanroepen, bevindingen samenvatten en vervolgens de uiteindelijke uitvoer produceren.

Elke lus zorgt voor meer inferentie. Wanneer dezelfde automatisering elke ochtend wordt uitgevoerd, honderden documenten verwerkt of voortdurend in een codebase werkt, kunnen kosten op basis van verbruik veel sneller oplopen dan bij incidentele chats.

Lokale inferentie verandert die kostenstructuur. Een deel van de cloudkosten per gebruik wordt vervangen door vaste kosten, zoals hardware, elektriciteit, opslag en onderhoud.

Dat maakt lokale AI niet gratis. De nuttigere vergelijking is de kostenafweging tussen lokale en cloud-AI.

Portable Computer formaliseert het hybride antwoord: houd werk met een groot volume of gevoelige gegevens op de hardware die je al bezit en zet cloudresources selectief in waar die een duidelijk capaciteitsvoordeel bieden.

Waarom hebben lokale AI-agents mogelijk een server of NAS nodig, zelfs wanneer de inferentie elders plaatsvindt?

Portable Computer draait momenteel op een AI-computersysteem, niet op een NAS. Er is geen reden om van dat feit een niet-onderbouwde bewering te maken dat het volledige product op een opslagserver moet worden geïnstalleerd.

De interessantere verbinding is architecturaal.

Naarmate agents persistent worden, verzamelen ze gegevens die veel langer blijven bestaan dan één inferentiesessie:

• brondocumenten en privébestanden,
• coderepositories en projectmiddelen,
• zoekindexen en embeddings,
• taakgeschiedenissen en agentlogboeken,
• gegenereerde rapporten en artefacten,
• geheugenbestanden en kennisbanken,
• workflowconfiguraties,
• snapshots en back-ups.

Niet al die gegevens hoeven permanent op de interne SSD van de machine te staan waarop de inferentie plaatsvindt.

Een volwassen local-first-architectuur kan drie resourcelagen scheiden:

De NAS hoeft niet te doen alsof hij GPU-geheugen is. Zijn rol is anders: een stabiele, uitbreidbare en van rechten voorziene thuisbasis bieden voor de duurzame gegevens van de agent.

Dit is dezelfde reden waarom een private AI-datal laag op een NAS kan blijven terwijl de inferentie elders plaatsvindt. De computerhardware kan veranderen zonder dat de volledige kennisbank hoeft mee te verhuizen.

Die scheiding wordt vooral nuttig in een omgeving met meerdere apparaten. Eén workstation kan overdag een krachtig lokaal model draaien, een ander apparaat kan lichtere AI-taken uitvoeren en een geüpgraded GPUsysteem kan beide later vervangen. Een persistente opslaglaag kan tijdens al die veranderingen dezelfde projectbestanden, embeddings, uitvoer, agentgeschiedenis en back-ups blijven bevatten.

Met andere woorden: de waarde op lange termijn ligt misschien niet in het model. Misschien ligt die in de toestand rondom het model.

Is Portable Computer de toekomst van persoonlijke AI-agents?

Portable Computer is nog te nieuw om te bewijzen dat elke persoonlijke AI-agent precies dezelfde architectuur zal overnemen. Het maakt verschillende bredere trends wel veel duidelijker zichtbaar.

Ten eerste gaan capabele lokale modellen verder dan privéchat. Een 27B-model kan nu deel uitmaken van een agentharnas dat taken plant, bestanden doorzoekt, tools uitvoert en werkzaamheden gaande houdt.

Ten tweede wordt het agentframework steeds belangrijker, net als het model. Orkestratie, het bewaren van taken, retrieval, machtigingen, sandboxen, connectors en geheugen bepalen wat het model daadwerkelijk kan bereiken.

Ten derde zijn volledig lokale en volledig cloudgebaseerde AI niet de enige keuzes. Portable Computer laat een praktischer midden zien: routinematige uitvoering kan op het apparaat blijven, terwijl de agent selectief om externe informatie of krachtiger redeneervermogen vraagt.

Er zijn nog altijd belangrijke beperkingen. De lancering draait om gespecialiseerde DGX Spark-hardware. Ondersteuning voor RTX-pc's wordt nog uitgebreid. Windows-ondersteuning maakte geen deel uit van de eerste release. Lokale modellen zullen frontier-modellen in de cloud niet bij elk complex redeneerprobleem overtreffen, en verbonden applicaties maken nog steeds gebruik van externe diensten.

Lokale uitvoering legt ook meer verantwoordelijkheid bij de gebruiker. Hardwarecapaciteit, opslag, machtigingen, back-ups, software-updates en agentbeveiliging worden allemaal onderdeel van het systeem, in plaats van onzichtbare cloudinfrastructuur te blijven.

Maar de ontwikkeling is veelbetekenend. De belangrijke verschuiving is niet simpelweg van cloud-AI naar lokale AI. Het is een verschuiving van door de cloud beheerde workflows naar door de gebruiker beheerde AI-infrastructuur die selectief cloudintelligentie kan inschakelen wanneer dat nuttig is.

Zodra dat gebeurt, is de machine waarop het model draait slechts één onderdeel van het systeem. Bestanden, indexen, geheugen, machtigingen, taakstatus, uitvoer en back-ups worden volwaardige onderdelen van de persoonlijke AI-infrastructuur — en juist die lagen zorgen ervoor dat local-first agents nog lang nuttig blijven nadat het model van vandaag is vervangen.

Veelgestelde vragen: Perplexity Portable Computer en local-first AI

Wat is Perplexity Portable Computer?

Perplexity Portable Computer is een local-first versie van Perplexity Computer die het model, de orkestrator, planner, toolrouter, planner, duurzame takenwachtrij en lokale zoekindex van de agent op de computer van de gebruiker uitvoert. Het kan lokale bestanden en workflows verwerken zonder clouduitvoering als standaard in te stellen.

Draait Perplexity Portable Computer volledig offline?

Het kan veel taken lokaal uitvoeren, maar het kan beter worden omschreven als local-first dan als local-only. De agent kan indien nodig zoeken in de cloud, verbonden applicaties, browsermogelijkheden of frontiermodellen gebruiken. Perplexity zegt dat het om toestemming vraagt voordat inhoud van het apparaat naar een clouddienst wordt verzonden.

Welk model gebruikt Portable Computer?

Bij de lancering ondersteunt Portable Computer Qwen3.8-27B en PPLX 27B, dat Perplexity beschrijft als een post-getrainde versie van het Qwen-model. NVIDIA Nemotron 3.5 Lightning staat ook gepland voor de modelkiezer.

Verstuurt Portable Computer privébestanden naar de cloud?

Perplexity zegt dat privégegevens op het apparaat kunnen blijven en dat het systeem om toestemming vraagt wanneer een taak inhoud van het apparaat naar een clouddienst moet verzenden. Gebruikers moeten verbonden apps en goedgekeurde escalatie naar de cloud toch beschouwen als externe gegevensstromen, in plaats van ervan uit te gaan dat het systeem permanent offline is.

Kan Portable Computer op een RTX-pc draaien?

Perplexity lanceerde Portable Computer eerst op NVIDIA DGX Spark en zegt dat ondersteuning voor NVIDIA RTX-gpu-pc's eraan komt. De exacte hardware- en softwarevereisten voor een bredere RTX-implementatie kunnen veranderen naarmate die uitrol vordert.

Heeft Portable Computer een DGX Spark nodig?

De eerste implementatie in september 2026 is gebaseerd op DGX Spark, maar Perplexity heeft al een uitbreiding naar RTX-gpu-pc's aangekondigd. Het onderliggende Qwen3.8-27B-model kan ook zelfstandig op andere lokale hardware draaien met geschikte kwantisatie en voldoende geheugen.

Is Perplexity Portable Computer hetzelfde als Ollama?

Nee. Ollama is voornamelijk een lokale runtime voor modellen en een API-laag. Portable Computer is een uitgebreider agentsysteem dat een lokaal model combineert met orkestratie, planning, persistente taken, lokaal zoeken, tools, apparaatacties, sandboxing, connectors en optionele escalatie naar de cloud. Ollama helpt een model uitvoeren; Portable Computer is ontworpen om een doorlopende agentworkflow eromheen uit te voeren.

Waarom heeft een lokale AI-agent persistente opslag nodig?

Persistente agents maken en hergebruiken veel meer dan alleen modelgewichten. Ze kunnen afhankelijk zijn van bronbestanden, zoekindexen, embeddings, geheugen, taakgeschiedenissen, werkruimten, gegenereerde uitvoer, logboeken en back-ups. Door die gegevens in een duurzame opslaglaag te bewaren, wordt het eenvoudiger om de rekenmachine te vervangen of te upgraden zonder de volledige werkomgeving van de agent opnieuw op te bouwen.