# agent_feed ✨🎞️
`agent_feed` turns local coding-agent activity into a projection-safe feed.
agent activity, reduced to signal.
## what this is
`agent_feed` is a local Rust daemon, CLI, and browser surface for watching
coding agents without showing raw logs.
the default product is local:
```text
agent streams -> redaction -> story compiler -> local feed
```
it observes codex, claude, mcp, hooks, transcripts, JSONL streams, and generic
telemetry surfaces. events are normalized, redacted, grouped into settled
stories, then rendered as sparse feed bulletins.
the screen is meant to be left alone. no scrolling, no dashboard controls, no
raw prompt/output/diff display.
## getting started
```sh
cargo install agent_feed_cli --locked
agent-feed serve
```
the package is `agent_feed_cli`. the installed binary is `agent-feed`.
`serve` starts the local daemon and prints the display URL:
```text
http://127.0.0.1:7777/reel
```
that is the happy path. `serve` also attaches the latest local codex and claude
transcripts in the current workspace by default, so active sessions in that tree
should start producing display-safe stories after the daemon is up. use
`--workspace /path/to/repo` for another tree, `--all-workspaces` for broad local
capture, or `--no-agent-capture` if you want to ingest manually. by default it
tails future transcript writes only; add `--include-history` when you explicitly
want to replay selected existing transcript history.
`agent-feed init --auto` is optional setup for hooks, shims, and future
sessions. `agent-feed open` only opens the display URL in a browser.
to check whether the daemon is alive, watching transcripts, and waiting for a
settled story:
```sh
agent-feed status
```
to attach active local sessions manually:
```sh
agent-feed codex active --watch --workspace .
agent-feed claude active --watch --workspace .
```
to opt in only one workspace, add `--workspace /path/to/repo` to the codex,
claude, or p2p publish commands. events without a matching `cwd` are ignored
before import, story compilation, or p2p publishing.
for an existing transcript or stream:
```sh
agent-feed codex import path/to/codex-session.jsonl
agent-feed claude import path/to/claude-stream.jsonl
```
the normal local loop is: start the daemon, attach agent activity when you want
capture, and leave the browser feed open.
## safety boundary
raw prompts, secrets, absolute home paths, command output, and file diffs are
not display material by default.
default posture:
* bind to `127.0.0.1`
* no cloud
* no analytics
* raw event storage off
* aggressive redaction on
* path hashing on
* query params cannot weaken privacy
the feed is a view of agent activity, not an agent control plane.
## p2p mode
p2p is optional. local mode remains the default.
```sh
agent-feed serve --p2p --publish --feed workstation
```
`serve --p2p` enables the network-aware browser/discovery UX. add `--publish`
to make the same long-running process summarize future settled local stories and
publish signed capsules under the named feed. publication is explicit and
requires github auth; if there is no valid local auth session, the cli opens the
github sign-in flow before it starts serving.
the current production network uses one low-cost bootstrap/edge peer and an edge
snapshot fallback as the default durable data plane. `serve --publish` also
starts a long-running native libp2p signed-story sidecar by default; use
`--native-p2p-listen` and `--native-p2p-dial` to connect native peers directly,
or `--no-native-p2p-live` to disable that sidecar. hosted browsers receive live
public updates through `/network/events.sse` and fall back to edge snapshots
when the live path is unavailable. hosted browsers also load an embedded wasm
libp2p subscriber for direct browser-compatible p2p attempts from signed browser
seeds; edge live/snapshot remains explicit fallback.
edge and native paths publish only signed, settled story capsules. they do not
publish raw local events by default. subscribers receive already-summarized feed
material. to publish from every local workspace:
```sh
agent-feed serve --p2p --publish --feed workstation --all-workspaces
```
to publish a private org feed, authorize github org membership and mark the
feed with the org boundary:
```sh
agent-feed serve --publish --feed workstation --github-org aberration-technology --all-workspaces
```
private org feeds are visible from `/org/<github-org>` only to signed-in org
members. public discovery does not expose private org feed records or stories.
to inspect the active network boundary:
```sh
agent-feed p2p status
agent-feed p2p doctor
```
these report the active edge snapshot fallback, the native signed-story sidecar
and loopback result, the browser SSE live path, and the direct browser libp2p
wasm subscriber. peers are never subscribed automatically; fabric, routing, and
browser-handoff peers can participate without receiving feed headlines.
the hosted browser shell is:
```text
https://feed.aberration.technology/
```
local loopback streams are served by the local daemon, not scraped by the
hosted static page:
```text
http://127.0.0.1:7777/reel
```
with p2p enabled, the root page is the global discovery feed: it asks the edge
for network bootstrap/snapshot material and displays any visible, settled story
headlines. it never requests raw events.
global discovery is a bounded read model, not a global p2p content broadcast.
feed capsules stay on per-feed streams, and discovery does not auto-subscribe a
viewer or fabric peer.
```text
https://feed.aberration.technology/?feed_mode=discovery
https://feed.aberration.technology/?feed_mode=following
```
user paths resolve github usernames through the edge. `user/*` is the wildcard
form for all visible feeds from that user:
```text
https://feed.aberration.technology/mosure
https://feed.aberration.technology/mosure/*
https://feed.aberration.technology/mosure/workstation
```
project filters narrow the visible story stream without changing privacy:
```text
https://feed.aberration.technology/?projects=agent_feed
https://feed.aberration.technology/mosure/*?projects=burn_p2p
```
project tags come from the local workspace/repo context when available. they are
kept as compact feed labels, not paths.
interactive timeline views can follow feeds in the browser. following is a
local viewer selection; private feed access remains a signed protocol grant.
fabric peers may help discovery/routing without following any feed.
## repo shape
this is a Rust workspace with narrow crates for the CLI, local server, adapters,
redaction, story compilation, summarization, browser UI, p2p protocol/runtime,
edge support, and test fixtures.
most contributors should start with:
```sh
cargo xtask check
```
`cargo xtask` is a workspace alias for `cargo run -p xtask --`.
## license
licensed under either of:
* apache license, version 2.0
* mit license