Local agent harness · Android

The agent harness, in your pocket.

Pocket Harness runs DeepSeek Harness locally on your Android phone — no root, no hosted backend. Your keys and sessions stay on the device.

Built on DeepSeek Harness 0.2.1-alpha.1 (MIT). Independent product, not affiliated.

Request early access See how it runs

Prefer to read code? Browse the public source — default branch in transition, see roadmap.

  • No root
  • On-device server
  • Offline bootstrap
  • MIT upstream
Home on the phone itself — real capture. More in Tour.

Scope

What it is — and what it isn’t

Pocket Harness is the full agent workspace, moved onto your phone. Stating the boundaries up front is part of the product.

What it is

  • A local agent harness. Chat threads, tool calls (read, edit, bash), persistent sessions, and a terminal — served by dsh web running on the phone itself.
  • A plugin platform. Preseeded with a market, free search, and media skills; install more from the community or write your own.
  • Your keys, your device. Model API keys are entered in-app and stored in a private on-device home. No account, no hosted relay.

What it isn’t

  • Not a hosted chatbot. There is no cloud backend to talk to — the server is a process on your phone, reachable only from the phone.
  • Not OS-sandboxed. Android can’t isolate processes the way Linux containers do, so the agent runs unsandboxed. Use it on personal devices and repos you trust.
  • No inbound webhooks. The server binds loopback only, so nothing on the internet can reach it. Scheduled work polls on-device instead.

Tour

Real screens, on-device

Three captures from the phone itself at 540×1090: the home composer, the plugin market, and settings. Each names the mechanism behind it — no staged renders.

Pocket Harness home empty state: session title, home folder and Creator mode selectors, composer reading Describe what you want to build, slash commands, at files or sessions
Home. Empty-state composer — / commands, @ files, and sessions route to dsh web on loopback.
Plugin Market on Android listing billion-context as Installed and DSH-better-sidebar and dsh-codex-ui with Install buttons, with search and filter
Plugins. Market with install states — billion-context installed via the preseeded dshmarket plugin.
Settings General tab showing Permission Full access, Language English, Appearance Light Dark System options, and Font size 14 pixels
Settings. General tab — permission mode, language, appearance, and font size persist in the on-device home.

Captures show the on-device web UI served by dsh web; the Pocket Harness mark is the checkmark-circle. Home capture keeps its upstream session title verbatim for honesty.

Runtime

How it runs on-device

Install the APK, let the first run provision the environment, add your API key. Every path below is resolved live on the device — nothing is hardcoded.

  1. Install the APK

    Android 7.0+, no root, no extra downloads. The APK carries the bootstrap and the full server bundle.

  2. First-run bootstrap

    Sets up an on-device Linux userland, Node 22, offline packages, and the server bundle from local assets.

  3. Local server starts

    dsh web listens on 127.0.0.1:3080 only. The app opens it in a WebView with a one-time token URL.

  4. Add your API key

    Enter it at first run or in Settings → Models. It stays in the private on-device home directory.

Runtime diagram: APK assets unpack into a Termux userland that runs dsh web on loopback port 3080; a token-gated WebView loads it; keys and sessions live in a private home
The full loop lives on the phone: TERMUX userland → Node server → WebView. Only model API calls leave the device, and only when you send them.

Capabilities

Capabilities with receipts

Six things the app does. Each one names the mechanism underneath — no adjectives without plumbing.

Agent workspace

Multi-turn chat threads where the assistant reads, edits, and runs commands in your on-device session — the same loop as the desktop harness.

Via dsh web sessions, served on loopback

Plugin system

Install community plugins, add free-model providers, and generate images or video frames — preseeded so the first run is useful.

Via dshmarket, opencode2dsh, imagegen/videogen

Terminal & files

A real shell with a pseudo-terminal and fast file search, so the agent can build, grep, and run tests like on a workstation.

Via NDK-built PTY + ripgrep, offline

Attachments & media

Shoot a photo or attach a file straight into a thread. Media is staged through an isolated cache, never your private home.

Via FileProvider cache-path staging

Search, no keys needed

Web and platform search works out of the box — no search-API signup, no key to paste — for research the agent can cite.

Via freesearch plugin, preseeded

Long-session resilience

Long threads get compacted instead of exploding: the context window is guarded and summarized so work survives the weekend.

Via overflow guard + /compact halving

Trust

Security and privacy

A table, not a promise. Every row states what is protected, by what mechanism — including the one row where the answer is “not protected”.

Security posture of Pocket Harness
Local-only server Enforced Listens on 127.0.0.1:3080. No other host on the network can connect; binding to all interfaces is rejected.
Token-gated views Enforced The WebView opens a one-time ?token=… URL. Opening the bare address returns 401.
Keys & sessions Private Stored in the app-private home ($DSH_HOME). Android backup is disabled (allowBackup=false), so they never leave in a backup.
File sharing Scoped Camera captures and “open in app” go through a cache-only FileProvider. Your private home is never exposed to other apps.
Permissions, justified Internet (model APIs + plugin downloads) · foreground service (keep the server alive) · camera + media (attachments only, on request).
OS-level sandboxing Not possible Container isolation needs privileges a non-root phone can’t grant. The agent runs unsandboxed and the app says so on-screen. Best for personal devices and repos you trust — not for running untrusted code.

Facts

Specifications

Exact versions and targets. If a number matters to your review, it’s here — not in a footnote.

Technical specifications
Packagecom.dsh.mobile · version 0.1.0 (2)
RequiresAndroid 7.0+ (API 24). No root.
SDK targetsminSdk 24 · targetSdk 28 (deliberate: running executables from the app directory, the same approach as Termux) · compileSdk 35
RuntimeNode 22 · on-device server on 127.0.0.1:3080 · WebView UI
Built onDeepSeek Harness 0.2.1-alpha.1, shipped pristine with mobile changes as separate patches + a plugin.
Sourcegithub.com/dafazar/pocketharness (public; default branch in transition — see roadmap).
PreseededPlugin market · free-model providers · keyless web search · image + video skills · one-tap file download.
Upstream licenseMIT (deepseek-ai/deepseek-harness). Pocket Harness is an independent product built on the open-source project.

Verification

Tested like infrastructure

Four automated gates run before every build. They’re counts of checks, not marketing numbers — each one names what it guards.

126

Wrapper tests

Across 27 files: bootstrap, server lifecycle, and the mobile plugin surface.

155

Parity gates

parity-check.sh: every documented feature verified present on-device.

21

Preflight gates

preflight-check.mjs: environment and integrity checks before packaging.

56/56

Patch graft checks

Upstream stays pristine: all mobile patches must apply cleanly, or the build stops.

Status

Status and roadmap

Where the project stands today, and what “later” concretely means. Nothing here links to something that doesn’t exist yet.

Now

Next

  • Tidy public repo: Pocket Harness README + docs on the default branch.
  • Signed release APK with published SHA-256 checksums.

Later

  • Play-compliant target SDK, after on-device execution is re-verified.
  • Richer background scheduling for polling-based automation.

Answers

Questions, answered

The six questions every reviewer asks. Short answers, no hedging.

Does it need root?

No. Pocket Harness runs in a normal app sandbox on Android 7.0 and newer. The trade-off is honest: without root there is no OS-level process isolation, so the app runs unsandboxed and tells you so.

Does it work offline?

Bootstrap is fully offline — the APK carries the userland, Node, and the server bundle. Day to day, only model API calls and plugin downloads need the network; some preseeded providers are free.

Which models and keys?

Bring your own API key — entered in-app at first run or later in Settings → Models — or start with a preseeded free provider. Keys are stored in the app-private on-device home and never leave except to call the model.

Why not just Termux + a manual install?

You absolutely can. Pocket Harness is that setup, productized: one APK, offline bootstrap, a token-gated touch UI, preseeded plugins, and 300+ automated gates before each build — instead of an afternoon of shell commands.

How is enterprise data handled?

Sessions and keys stay on the device; the server binds loopback only and backups are disabled. The known boundary: no OS sandbox, so evaluate it for personal devices and trusted repos — the security table states this plainly.

How do I get it?

Email mobileharness@pocketharness.my.id to request a test build. The source is already public at github.com/dafazar/pocketharness (note: default branch in transition — still shows an earlier project; Pocket Harness docs live on a separate branch). Signed APK with checksums follows; see the roadmap.

Early access

Get Pocket Harness

Test builds go out by email. Tell us what you’d run on it — we read every request.

Request early access

Or browse the public source on GitHub — builds still go out by email while the default branch is tidied.