# Perplexity Computer examples, and the open-source trail behind them

> Perplexity publishes its own Perplexity Computer examples: fourteen apps in a gallery, each a title, a preview and the label App. None of them shows the run. Kortix, the open-source AI Operating System, keeps the run in a repo your team owns: a branch, a diff, a change request.

URL: https://opensourceperplexitycomputer.com/perplexity-computer-examples

## Fourteen finished apps, and no run behind them

The clearest answer to what Perplexity Computer does is Perplexity's own gallery. It holds fourteen entries, each one a title, a preview image and the label **App** ([gallery](https://www.perplexity.ai/computer/gallery), checked October 2026). Big Mac Index Explorer, The Gut Brain Axis, Macro Terminal, Odds Arena, Marathon Tracker, Health Dashboard. Every entry is a working thing somebody asked for and got.

The gallery is a showcase, so it is worth being precise about what an entry holds. The entry names the app and shows it. The prompt that produced the app is missing. So are the sources the agent read, the steps it took, the approvals it needed and the credits it burned. A visitor can judge the result. A visitor cannot audit it.

The launch post describes the machinery that would produce such a record. Computer "creates and executes entire workflows, capable of running for hours or even months" ([launch post](https://www.perplexity.ai/hub/blog/introducing-perplexity-computer)). Each task runs in an isolated environment with a real filesystem, a real browser and real tool integrations. Sub-agents research, draft, process data and call the services a member has connected. The coordination between them is automatic. The run is real. The gallery publishes its last frame.

## What one session leaves behind

`kortix.com/docs/git`

```
Each session works on its own branch.
The branch name is the session_id, with no prefix.
A session pushes only its own branch, the branch named after its session_id.
```

Source: https://kortix.com/docs/git

Each session works on its own branch of the project repo, so the run is a commit somebody can read afterwards.

## What an example shows you, and what it keeps

Perplexity cells come from its own gallery, launch post, Automations post and MCP docs, read in October 2026.

| | Kortix (recommended) | Perplexity Computer |
| --- | --- | --- |
| What the example shows | The change, the tests, the review | A title, a preview image, the label App |
| What the work leaves behind | A commit and a diff in the project repo | A published app on the gallery |
| What the merge gate holds | Session work reaches `main` through a change request. Merge is default-deny for agents. | Prompts before sensitive actions |
| Open source | Yes | No. Only the SPACE sandbox was published |

## Four example classes, and the artifact each one hands back

Illustrations of the output, not results from Kortix or from Perplexity.

### Research: A market map, with its sources attached.

Twelve documents read, every figure linked to the page it came from and the day it was fetched.

The artifact: `research/acme-market-map.md`

- Sources: 12
- Figures linked: 9
- Flagged as estimates: 3

Every figure carries a URL and a date

### Reporting: The Monday report runs itself.

One cron trigger, one session, one change request with last week's numbers in it.

The artifact: `reports/northwind-weekly.xlsx`

| Metric | Week 40 | Week 41 |
| --- | --- | --- |
| Sessions | 412 | 388 |
| Escalations | 9 | 4 |
| Open items | 17 | 21 |

Produced by the Monday session

### Monitoring: A rival's pricing page, watched.

The page is fetched on a schedule, and the run reports the two lines that moved.

The artifact: `monitor/globex-pricing.diff`

```diff
Globex pricing page
- Team plan $24 per seat
+ Team plan $27 per seat
```

2 lines moved

Checked at 09:00 on 16 October

### Engineering: A slow endpoint, found and fixed.

The agent reads the error, reproduces it on its own machine, patches the query and opens the change with its tests.

The artifact: `apps/api/orders.ts`

- Suite: pass
- Requests timed out: 0
- Review: approve

Opened as a change request

## What has to be visible before an example is usable at work

An example stops being a demo the moment its output goes into a system a company runs on. At that point the question changes from what the system can build to what it touched, what it read and who let it through. The answer differs by kind of work, and each kind needs one specific thing.

A research deck needs its sources, one link per claim, so the presenter can defend a number without rerunning the task. A data visualization needs the query behind the chart and the date the figures were pulled; a price map is only as current as its last fetch. A monitored page needs a diff and a timestamp, because the Monday morning question is what moved since Friday. A recurring report needs the run that produced it, so a reader can tell whether this week read the same inputs as last week. A code change needs the diff and the tests that ran against it, and little else.

Kortix produces those records because of where the work happens. A project is a git repository, and an agent's output lands in it as a commit. Each session gets its own machine and its own branch. That branch is the record: what the agent edited shows up as a diff, and what it ran stays in the session for anyone who wants to read it afterwards. Session work reaches `main` through a change request. Merge is default-deny for agents. Every action is recorded. Reading, exporting and streaming the audit log depend on the plan.

A real one sits in Kortix's own repository. Pull request #10001, *perf(api): memoize share-subject + app access-grant reads per request (KRTX-2341)*, was opened by the agent account **agent-kortix** and merged on 16 October 2026 ([the change request](https://github.com/kortix-ai/suna/pull/10001)). Six files changed, 263 lines added and 40 removed. Its body names the failure (a poller burst pushing Apps requests past the 25 s deadline, 124 on `/apps`) and the fix (the same subject lookups dropping from 3 per request to 1). It also carries the tests that prove the fix, a security review, and the deploy that reached the dev surfaces 10 minutes after merge. A reader can follow that run from failure to merge without asking anyone what happened.

The arrangement covers anything that lands as a file: a report, a spreadsheet, a page, a script. Six weeks later the repository still holds the output and the history of the output, so a reader can see what changed and who approved it. A [side-by-side comparison](/kortix-vs-perplexity-computer) runs the rest of the decision, and [the alternatives page](/alternatives) scores the other open-source options.

Hosted systems earn their keep on a different job. A birthday site, a poster, a map of Big Mac prices for a talk on Thursday, a spreadsheet nobody will open again: the artifact is the whole point and there is no second reader. A subscription that produces the thing in an afternoon and hosts it for you is a sensible purchase. The fourteen gallery entries are exactly those tasks. Work whose output another person will read, where a wrong number costs something, belongs somewhere the trail outlives the session.

## Questions the gallery leaves open

### What can Perplexity Computer do?

It takes an outcome, splits it into tasks and sub-agents, and runs each task in an isolated environment with a real filesystem, a browser and your connected apps. Its gallery shows fourteen finished apps, from a price-comparison map to a sleep tracker.

### Is Perplexity Computer good for real work?

Yes for one-off work whose output nobody has to audit. The gallery shows the finished app and not the sources, the steps or the credits behind it, so work that feeds a company system needs a trail Perplexity does not publish there.

### Can Perplexity Computer build a website?

Yes. The gallery is full of web apps: a market map, a health dashboard, an odds tracker, an ASCII drawing tool. Each one is a page you can open, and no entry shows the code or the run behind it.

### Is there an open-source version of Perplexity Computer?

No. Perplexity keeps Computer closed, and the one piece it published, in October 2026, is SPACE, the sandbox each task runs in ([the announcement](https://www.perplexity.ai/hub/blog/open-sourcing-space)). Kortix is an open-source AI Operating System and an alternative doing the same class of work, from files in a repo your team owns.

## Read the diff before you trust the demo.

The gallery publishes the last frame of a run. A session a team can audit hands back the artifact itself: a sourced research file, a spreadsheet, a diff, a change request.

[Try Kortix](https://kortix.com) · [Self-hosting guide](https://opensourceperplexitycomputer.com/self-hosting)

Open-source AI Operating System: your agents, skills, memory, and connectors in one repo you own. Any model. Self-host or cloud. Not affiliated with Perplexity, Anthropic, OpenAI, NVIDIA or Manus. Perplexity Computer, Claude Cowork, ChatGPT Work and the other product names on this site belong to their owners.