paratenic

Plate VI · Culture

One client for every host.

Culture is where you watch and steer the agents your hosts carry. One Rust core holds an independent connection to every host you configure; native surfaces put it in a terminal, a browser, a Mac, an iPhone, an iPad, an Apple Watch, an Android phone and a Wear OS watch.

The core

One Rust core, native everywhere

One Rust core, native everywhere Culture connects to each configured host — Paratenic on atlas, Paratenic on vega, pi-daemon or any other AHP host — through paratenic-client-ws, one authenticated transport per host. paratenic-client-core holds host-qualified replicas, command receipts, the cross-host inbox, feed and session index. Four bindings carry it to every surface: Ratatui in-process for the terminal; paratenic-web with a WASM module for the browser; the paratenic-client-ffi C ABI for SwiftUI and AppKit on macOS, iPhone, iPad and Apple Watch; and UniFFI for Kotlin and Compose on Android and Wear OS. atlasParatenic vegaParatenic pi-daemonor any AHP host client-wsa transport per host client-corereplicas · receiptsinbox · feed · index Ratatuiin-process paratenic-webnative server + WASM C ABIparatenic-client-ffi UniFFIKotlin bindings terminal browser AppleMac · iPhone · iPad · Watch Androidphone · tablet · Wear OS SHARED RUST
Fig. VI.1Every surface gets the same replicas, receipts and inbox; only the presentation is native.
  • Per-host everythingOne transport, reconnect, sequence and token per host — Paratenic, a pi-daemon node or any AHP 0.8 host. Every row, command and answer is qualified by the host it belongs to.
  • Shared subscriptionsTwo panes showing one chat share one wire subscription; a hidden pane holds no stream.
  • Receipts, not hopesPending, accepted, rejected and indeterminate stay distinct on every surface, exactly as the host reports them.
  • Fast where it mattersTwenty visible panes render in 0.80 ms on average; searching 1,000 sessions across 100 hosts takes 0.48 ms.

Terminal

A keyboard workspace for many agents

Culture in a terminal: two hosts in the catalogue on the left, Release guide on Atlas and Test sentinel on Vega side by side, both streaming, with tool runs and reasoning
Rendered from a live culture session against two disposable hosts and invented sessions.
  • Tabs and recursive splits| and _ split, ctrl+h/j/k/l move, counts and gg/G scroll.
  • Across hostsg i opens the global inbox of questions; g f the activity feed.
  • Real terminalsAHP PTY terminals render through a native VT emulator in their own panes.
  • Scriptableculture list, culture send, and culture control over an owner-private socket; culture run --headless for automation.

Web

The same workspace in a browser, served by the same binary

Culture Web in dark mode: the agent catalogue grouped by Atlas and Vega, two chats split side by side, a pending release question with Decline and Submit
Culture Web inbox: two questions waiting, one from Atlas and one from Vega
Inbox: every pending question, every host.
Culture Web feed: responses, tool runs and reasoning from several agents, following live across all hosts
Feed: following live across hosts.
  • No second clientculture web serves a compiled bundle; native Rust keeps the AHP connections, credentials and command authority, and every browser tab shares them.
  • Nothing to installNo Node, checkout or hidden terminal at runtime. Light and dark follow the system.
  • Your perimeterA wildcard bind has no application password: put it behind your own authentication or keep it on a trusted network.
  • As a serviceservices.culture.web runs it as an opt-in user service, independent of any host.

macOS

A native Mac app over the same core

Culture for macOS: a conversation with a completed Rust test run in a tool card, reasoning, and the composer with model and context controls
Culture for macOS command palette: commands and agents across hosts
Culture for macOS New agent sheet: host, provider and working directory
  • SwiftUI and AppKitTalks to the Rust core through the paratenic-client-ffi C ABI. Liquid Glass on macOS 26; system materials on 14 and 15.
  • Everything at handHost-qualified source rail, conversation, tools and input, terminal frames, change and detail inspectors, native session creation, diagnostics, widgets.
  • One updateOn Apple Silicon, culture update verifies and replaces both the CLI and Culture.app from the same release.

iPhone, iPad and Apple Watch

In your pocket, and on your wrist without it

Culture on iPhone: the feed across all hosts, with a release question and a design review Culture on iPhone: the inbox with one release-lane choice Culture on Apple Watch: Recent and Inbox Culture on Apple Watch: a conversation with a dictated Reply button
  • UniversalOne SwiftUI app for iPhone and iPad, iOS and iPadOS 17 and later, with cache-only, redacted widgets.
  • A watch that stands aloneAfter a secure configuration transfer from the phone, the watch connects to your hosts over Wi-Fi itself, on watchOS 10 and later.
  • Safe on the wristApprove or deny, pick a choice, dictate a short reply, or stop a turn when the host says it can. Anything larger hands off to the phone.

Android and Wear OS

Compose on the phone, a real client on the watch

Culture on Android: agents grouped by Waiting for you, Working and Recent Culture on Android: a release agent's turn with tool runs, a pending question and context telemetry Culture on Wear OS: agents with a live progress ring Culture on Wear OS: answering a question on the watch
  • Same runtimeThe Rust core through generated UniFFI bindings, with adaptive phone and tablet layouts, splits, focused panes and feed filters such as Agent replies.
  • Floating agentsOptional floating agent windows, coordinated with Flotilla when it is installed.
  • Standalone Wear OSThe watch owns its own AHP runtime over Wi-Fi or cellular, with encrypted configuration and an optional embedded tailnet identity. Tiles and complications read only a redacted cache.
  • DeliveryTagged releases go to Play internal testing, phone and watch together.

Labs

Where the next interface is tried first

Petri

An experimental controller workspace for driving many agents with a keyboard or a gamepad, eyes on or off: a conversation stream, real model suggestions, dictation, and semantic feedback in sound — distinct chimes for direction, history, suggestions and outcomes, and a chosen voice for each kind of action.

Petri desktop: an agent roster, a conversation stream for Navigation polish, and a control deck with a D-pad
ActionKeyboardGamepad
previous / next agent← →D-pad left / right
previous / next history↑ ↓D-pad up / down
previous / next groupQ ELB / RB
suggestSWest
send draftEnterEast
talkSpaceNorth
stop audio, else interruptXSouth
Petri on a phone: the control deck Petri on a phone: eyes-off feedback settings with chime and speech volume

It starts on a clearly marked demo studio; PETRI_DEFAULT_BACKEND=culture switches it to your Culture hosts, and services.petri runs it as a Nix service on port 7790. Dictation fills a draft and never sends on its own. Like every client, it cannot stop a terminal Pi — that path refuses Stop.

The Android design lab

The Android design lab streaming a turn live: reasoning, a tool run and a reply writing in

Debug builds install a second launcher, Culture lab, which plays the proposed next interface from a deterministic simulated agent: a turn trace on one hairline, streaming that catches up smoothly, a presence orb whose ring shows state, a command-deck composer, numbered decision tiles and diff approvals. Its proposals shipped in Culture for Android 2.8.0.

Design lab: a decision with numbered options Design lab: an edit approval with a diff Design lab: two live panes stacked on a phone

Automation

Every surface can be driven and checked

Each Culture exposes an owner-private way in: culture control and culture web control sockets, the macOS app’s UI command server, and loopback-only automation bridges in Android and Apple debug builds. Every frontend also carries a machine-checked conformance manifest against one platform-neutral Culture specification, so “parity” is a file a test reads, not a claim.