@tangle-network/agent-app weekly downloads statistics

@tangle-network/agent-app

The application-shell layer for building agent products on the Tangle stack.

The substrate packages — @tangle-network/agent-runtime, agent-eval, agent-integrations, tcloud, sandbox — are the engine. This package is the shell: the chat tool-loop, the structured agent→app side channel, the integration-hub client, per-workspace billing, field crypto, and the web boundary utilities that every agent app otherwise rewrites by hand. You supply your domain through typed seams; the package supplies the mechanism and imports none of your code.

Who it's for: engineers building an agent product on the Tangle sandbox — a chat app, a copilot, an autonomous worker — who want the shell (chat routes, streaming, durability, approvals, billing, the tool side channel) as composable pieces instead of a per-app rewrite. It is not an agent framework or a model SDK: the reasoning lives in the sandbox agent; agent-app is everything around it — the turn plumbing, durability, and money.

Highlights

• Structured tool side channel — submit_proposal (approval-gated), schedule_followup, render_ui, add_citation, exposed as validated tool calls over three surfaces (HTTP route, per-turn MCP server, agent-runtime executor). No fenced-text parsing. • Bounded tool loop — runAppToolLoop / streamAppToolLoop: stream a turn → collect tool calls → dispatch → fold results back → re-run, capped. These are 1:1 aliases of runToolLoop / streamToolLoop from @tangle-network/agent-runtime/tool-loop (the engine owns the loop; this package adds no logic on that path). Substrate-free behind a streamTurn seam, so it drives a sandboxed agent, a Worker, or an in-browser copilot unchanged. • Assembled chat vertical — createChatTurnRoutes wires auth → thread/message store → streaming turn with buffered replay → uploads → sidecar question answering into one route factory, over authorize / produce / store / interactions seams. No hand-rolled orchestration. See examples/chat-app.md. • Sandbox-optional — the same tools, billing, eval, and loop work without a container. A fetch-only adapter maps any OpenAI-compatible stream (Tangle Router, tcloud) into the loop. See examples/browser-copilot.md. • Resumable turns — buffer a turn so a dropped tab loses nothing and a reconnecting client replays the tail. Two niches: a browser/edge copilot streaming the Router directly (no sandbox session to attach to), and any detached sandbox run driven through dispatchPrompt({ detach: true }) / streamPrompt that a browser must tail. Sandbox 0.37 driveTurn uses the message lane and can be tailed through the session gateway. An INTERACTIVE sandbox turn doesn't need it — drive it on the message lane (box.session(id).sendMessage()) and attach the tab with box.mintScopedToken() + SessionGatewayClient, or let the worker resume with box.streamPrompt('', { executionId, lastEventId }). See examples/resumable-turns.md. • Composes the engine, never forks it — /eval re-exports @tangle-network/agent-eval's verifier; /integrations wraps the hub; /tangle and /billing take the tcloud client as a structural contract. Engines are peer dependencies — you pin the version, nothing is bundled. • ESM, typed, zero runtime deps in the substrate-free modules (/runtime, /web, /crypto, /redact, /stream). Ships with .d.ts and npm provenance.

Install

The engine packages you actually use are peer dependencies — install the ones your modules touch:

| Peer | Required by |

| @tangle-network/agent-eval | /eval, /eval-campaign, /profile, /knowledge | | @tangle-network/agent-runtime | /runtime, /chat-routes | | @tangle-network/agent-integrations | /integrations | | @tangle-network/agent-interface | /interactions, /chat-store, /harness | | @tangle-network/sandbox | /sandbox | | @tangle-network/agent-knowledge | /knowledge-loop | | @tangle-network/agent-profile-materialize | /skills-placement | | @tangle-network/sandbox-ui | /brand, /work-product-react, /workspace-react | | @tangle-network/ui | /brand, /work-product-react, /workspace-react |

package.json defines the supported peer ranges. Run pnpm exec agent-app-peer-check to check the installed dependencies.

All of these except agent-eval, agent-integrations, and agent-interface are declared optional peers, so a product that never imports the subpath installs nothing.

Modules that import no engine package (/tools, /web, /crypto, /redact, /stream, /billing, /tangle — the last two take their client as a structural contract) need no peers.

For reports, dashboards, admin pages, and record lists, start with the shared operational-page compositions. For the conversational UI, start with the default workspace.

Quick start

A product supplies its taxonomy (which proposal types exist, which are approval-gated) and its handlers (the real DB/vault writes), then wires the tool side channel to whichever surface it runs on.

streamTurn is the one seam that varies by backend. For an in-browser or edge copilot talking to an OpenAI-compatible endpoint, you don't write it by hand:

The full three-transport walkthrough (Tangle Router, tcloud, Vercel AI SDK) is in examples/browser-copilot.md.

Building the full server chat vertical instead — auth, thread/message tables, a streaming turn with buffered replay, uploads, and sidecar question answering — is the job of createChatTurnRoutes (/chat-routes) and the modules around it. The end-to-end assembly, including the durable plan/question workflow and the client composer, is in examples/chat-app.md.

How it's organised

One rule decides where anything lives:

Does the capability make sense without a specific app's tool side channel, approval queue, or chat route? Yes → it belongs in an engine package (contribute it down). No → it's app-shell, and it belongs here.…

Description from the npm listing.