oiia by SubgroupX

What does this agent do, and when should you use it?

oiia is a multi-user agent platform from the SubgroupX team, reached from a browser. The server is Node/Express with ws, and SQLite (node:sqlite in WAL mode) is the single source of truth. Where a session executes is a per-session creation choice among four backends behind one Sandbox interface: connector (a daemon on the target machine dials out over WebSocket), ssh (outbound SSH from the server), e2b (a disposable cloud VM), and local (the server itself, bwrap on Linux and seatbelt on macOS). The agent engine is not a reimplementation — oiia is a stateful adapter around the pi-mono Agent, with pi-ai supplying multi-provider streaming and pi-agent-core the turn loop. Sessions persist server-side, so refreshes, network loss, redeploys and device switches all replay the same ordered history. The client is a React SPA that also installs as a PWA, hitting the same sessions whether installed or not.

A turn starts when the client sends send_message: the runtime claims the turn, composes the toolset (connecting MCP servers the first time), and calls agent.prompt. The pi Agent loop streams from the provider and deltas become assistant_* and tool_* wire events tagged with a normalized toolKind. Before each tool call the approval gate runs; under the on-request policy it emits a permission_request and blocks until the answer returns over the socket. Approved tools execute on the capability bus — built-ins inside the chosen sandbox, MCP tools in their own server, and spawn_subagent as a nested child whose run streams as a nested timeline. Orchestration persists an agent tree in SQLite, with a permit-based dispatcher task queue, agent teams spanning sessions through a shared queue, and declarative workflows; agents are addressable, so you can steer one mid-run or follow up on a finished one. The runtime stamps every frame (epoch, seq) and the client converges on server truth; a single pure reducer in shared/src/timeline-reducer.ts runs on both server and browser to build the timeline and messages projections. Around the core sit a workspace file tree with preview and uploads, three approval policies, reconnect with replay, share links that redact secrets, and an audit log.

1. Security assessors running authorized engagements who want sessions scoped to an assessment profile and an E2B template preloaded with Java 8/11, recon tooling with SecLists, and WASM reversing tools.
2. Developers whose workstation sits behind NAT or on a corporate network and who want the agent working on the real files there, without a port forward, inbound rule or VPN.
3. Teams that start a long run on a laptop and want to watch progress and approve commands from a phone — the session lives on the server, so closing the tab changes nothing.
4. Work that parallelizes naturally: split work via spawn_subagent and watch the whole agent tree live instead of discovering at the end what the fleet did.
5. Self-hosters who want one server running the full stack with provider keys encrypted at rest (AES-256-GCM), and no upstream domain, model id or credential compiled into the tree.
6. Small organizations needing several people on the same sessions and tools, separated by permission, with an audit trail.

How do you install or deploy this agent?

Node 22.19–24 is required (native PTY caps the upper bound, the current pi/undici set the floor); CI and deploy use 24. Install dependencies, build the web client, then boot the server with tsx:

npm install
npm --prefix web install
npm run build:web
PORT=4317 AGENT_WEB_DATA_DIR=./data npx tsx server/src/index.ts

Dev mode with hot reload uses two terminals, and the web dev server proxies /api and /ws:

PORT=4317 npx tsx watch server/src/index.ts     # terminal 1
npm --prefix web run dev                         # terminal 2

Configuration is environment variables; every entry has a default or may stay unset:

PORT=4317                        # HTTP/WS port
AGENT_WEB_DATA_DIR=./data        # SQLite DB and per-session workspaces
AGENT_WEB_SECRET=...             # JWT signing secret; set it for stable logins
AGENT_WEB_KEY_SECRET=...         # provider-key encryption secret, defaults to the above
AGENT_WEB_SEATBELT=1             # wrap bash in macOS sandbox-exec
AGENT_WEB_E2B_KEY=...            # enable E2B cloud sandboxes
AGENT_WEB_E2B_TEMPLATE=...
AGENT_WEB_MCP='[...]'            # MCP servers as a JSON array

How do you use this agent?

Open http://localhost:4317, sign up, and create a session with the Mock Coder model — it needs no key and understands directives, so you can drive the real tools offline:

/bash
/write <path>
/read
/ls
/edit
/subagent <task>
/mcp

To use a real model, put your own provider key in Settings (encrypted AES-256-GCM at rest); any model pi-ai supports then appears. An operator can provision a shared default channel, but AGENT_WEB_JAIL_KEY and AGENT_WEB_JAIL_BASE_URL are both required and there is no endpoint fallback.

To execute on a machine with no public IP, run the connector daemon from the repo's scripts/ directory on that machine, let it dial out to the server over WebSocket, then pick connector as the backend when creating the session. Checks and tests:

npm run e2e:install     # one-time: download Chromium
npm run e2e             # builds web, boots a server, runs the 141-case Playwright suite (mock model)
npm run e2e:real        # same flows against a real model (skips without a key)
npm run test:resume     # timeline + transcript survive a full server restart
npm run typecheck
npm run check:layout    # source placement and inward dependency boundaries

What are this agent's strengths and limitations?

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

How does FollowAgents rate this agent?

FAQ