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:
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
the package is agent_feed_cli. the installed binary is agent-feed.
serve starts the local daemon and prints the display URL:
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:
to attach active local sessions manually:
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:
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.
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:
to publish a private org feed, authorize github org membership and mark the feed with the org boundary:
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:
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:
https://feed.aberration.technology/
local loopback streams are served by the local daemon, not scraped by the hosted static page:
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.
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:
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:
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:
cargo xtask is a workspace alias for cargo run -p xtask --.
license
licensed under either of:
- apache license, version 2.0
- mit license