ARIS OS — Agent-native Runtime for Intelligent Systems
The OS that
runs itself.
Agent-native · Self-improving · Yours
ARIS OS is a DeepSeek Harness–based operating layer for your laptop or Android device. It watches your machine, owns your files, talks to the world — and rewrites itself to get better. Built for the era when your machine does the work.
01
Built for the agent era
Every operating system you have used was designed for direct manipulation — you point, you click, you type. The agent era inverts that relationship: your machine watches, reasons, and acts on your behalf. ARIS OS is the operating layer built for that world.
01
An OS, not an app
Not a chatbot window. Not a website. ARIS is an operating layer: it owns your files, reads your machine, touches your network — the way an OS does, except it has agency.
02
One machine. Two operators.
You and your agents share the same processor, the same files, the same network. Sessions are processes with workspaces — real directories your agents read and write.
03
Improvement by design
No vendor, no waiting for the next release. The harness reads its own code, runs its own tests, patches its own tools. Improvement is a loop — not a release.
02
Sessions are processes
In ARIS, every conversation is a process with a workspace — a real directory the agent lives in. The shell follows the active session: switch conversations and the filesystem browser, the terminal prompt, the whole surface re-anchors to that agent's working directory.
- Workspace-follow — the file panel and the
~/<workspace>prompt track the active conversation. - Session-as-process — each agent gets a real home on disk, with real files it can read and write.
- One shell — human and agent operate from the same terminal surface.
aris@your-device:~/agents/coder$ ls README.md src/ patches/ memory/ improvements.log aris@your-device:~/agents/coder$ patch composer-caret-drift → rewrote 2 files · 0 regressions aris@your-device:~/agents/coder$ commit "caret fix — self-applied" [3b7f] committed aris@your-device:~/agents/coder$
03
The OS knows the machine it inhabits
YEAR 2025 · UPTIME
00:00:00
CPU
#1-2 0%
#3-4 0%
#5-6 0%
#7-8 0%
MEMORY
MEM
SWAP
PROCESSES
| PID | Name | CPU% | MEM% |
|---|
Per-core CPU with live sparklines. Memory and swap in block bars. Thermal state, top processes, load average, hardware identity. The machine's inner life, rendered in phosphor — visible to you, and to your agents.
- Real host telemetry — read from the machine ARIS runs on, not a mockup.
- Per-core history — the system keeps a memory of its own load.
- Shared awareness — what the OS sees, your agents see too.
04
The OS sees the network
Interface state, ping, and live traffic — plus the world rendered as a sphere your agents move across, with spline links stitching endpoints together.
- Network status — interface, state, address, latency at a glance.
- World view — a live globe with endpoint markers and links.
- Traffic — up/down throughput charted against a grid.
INTERFACEwlan0
STATECONNECTED
PING12ms
TRAFFIC
US-WEST 12msUS-EAST 21msEU-CENTRAL 96msAP-SOUTH 142msAP-NORTHEAST 118ms
05
One filesystem, two operators
▣src
▣patches
▣memory
▤README.md
▤improvements.log
▤config.json
▤agent.ts
▤tool.ts
STORAGE
118 / 512 GiB
Browse, preview, and edit the same files your agents work with. The filesystem is the shared memory of you and your machine — one tree, two operators.
- Shared ground truth — what the agent wrote is right there to inspect.
- Live preview — text, code, and images open beside the tree.
- Workspace-follow — the panel re-anchors to the active session's folder.
06
The loop the whole system runs on
ARIS does not wait for updates. It observes its own behavior, reasons about what to change, acts on its own code, and learns from the result — then does it again. The harness is both the doctor and the patient.
◉
Observe
◎
Reason
⚙
Act
↗
Learn
[OBSERVE] shell mount 210ms — target 90ms [REASON] hotspot: layout-frame reshape cost [ACT] patched frame pin — 3 lines [ACT] rewrote sparkline renderer — 0 allocs [LEARN] recorded patch to memory/ [OBSERVE] mount now 84ms — 60% faster [LOOP] continuing. nothing waits.
This is not a demo — it is the architecture. The same harness that drives the agents also drives the OS's own improvement: tools get rewritten, the shell gets refactored, the runtime gets tuned, and every change is logged where you can read it.
- Self-applied patches — the system modifies its own code, with tests.
- An audit trail — every improvement is written to the workspace.
- You stay in charge — the loop runs on your machine, for you.
07
Any device. Your device.
ARIS OS runs where you are. No cloud account, no datacenter dependency — the agents live on the machine in your hands.
LAPTOP
Your workstation, awake
Full telemetry, world view, and agent workspaces on the machine you already work on. Local-first — your files and your agents never leave it.
ANDROID
The OS in your pocket
Same shell, same agents, same workspace — on a device that fits in your hand. The machine with you is the machine that works for you.
LOCAL-FIRST
Private by default
No mandatory cloud. Telemetry stays on-device, workspaces stay on-device, improvements stay on-device. Your OS is yours.
08
Try the shell
This is what running ARIS feels like. Type a command below — help to start.
aris@your-device:~$
09
Install
ARIS OS is distributed as a plugin for the DeepSeek Harness. Two commands, one profile, and the shell is live on your GUI.
# from the harness checkout pnpm dsh plugin --profile web add @danielng23/dsh-edex-ui pnpm dsh web
Requirements
Node ^22.19 || >=24 · pnpm · a deepseek-harness checkout (or the published plugin flow). Everything writes only to ~/.dsh and your own machine — the harness checkout is never modified.
Purely additive
The shell overlays the original UI — nothing is replaced. Unload the plugin and the stock surface is restored exactly. Your theme preference is never touched.