> ## Documentation Index
> Fetch the complete documentation index at: https://rakumux.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent feed

> What your agents said, and the chats behind it, from every machine signed in to your Rakumux account.

The **Feed** lists what your agents said when they finished a turn, from every machine signed in to
your [Rakumux account](https://rakumux.com/docs/account/sign-in.md), newest first. In Rakumux it's a pane on the right, beside
the session you're looking at. It's hidden when Rakumux starts and opens only when you ask: press `f`
(or click **f ≡ Feed** in the footer) to show it with the keys, `f` again while it has them to hide
it, and `Esc` to give the keys back to the list. Drag the line on its left to resize it.

![Rakumux with the Feed open on the right: a turn read whole, its prompt, the agent's steps and answer, and a reply written back on rakumux.com in its thread](https://mintcdn.com/human-unsupervised-pty-ltd/0vQlovgyyhEkGszX/images/tui-feed.png?fit=max\&auto=format\&n=0vQlovgyyhEkGszX\&q=85\&s=d627ac2d45af495b4bcb81a5bcbc17e6)

With the keys, `↑`/`↓` (`j`/`k`) go through the cards. Each card names its session, agent and
branch, with its age and status on the right, then your prompt and the start of the answer; a
prompt still waiting for its answer is a **working** card. `Enter` reads a turn whole in the cards'
place, with its thread when someone wrote back, and `Enter` again goes into its session when it runs
on this machine. `r` writes back to a session's newest card ([below](#reply)).

The pane needs room beside the session: in a narrower window it takes the session's place in
Rakumux mode only, so a session you're typing in keeps its full width, and `b` (hiding the list)
makes room for it. Grid shows it beside the cards, Tabs gives it a **Feed** tab at the start of the
tab bar, and on a phone it fills the screen. While it's hidden, **f ≡ Feed** counts the turns that
arrived since you last had it open (●3).

## Read it on rakumux.com

Signed in, the web app opens on **Sessions** ([below](#your-sessions-on-the-web)). The Feed's button
(**≡**) at the top right of the header shows or hides your feed in a column on the right (on a phone,
in place of the list); this browser remembers which, hidden at first. Where three columns don't fit
(narrower than 1100px), the feed takes the session list's place while it shows. The rest of your
account is under the **Settings** gear at the top right, and the Rakumux logo always takes you back
to Sessions. While the feed is hidden, its button shows how many turns arrived since you last had it
shown in this browser (●3; it checks once a minute while the tab is in view).

![Sessions on rakumux.com: three machines' sessions grouped by status with their places, a Claude Code chat with a reply and a screenshot sent from the browser, and the Feed on the right](https://mintcdn.com/human-unsupervised-pty-ltd/0vQlovgyyhEkGszX/images/web-sessions.png?fit=max\&auto=format\&n=0vQlovgyyhEkGszX\&q=85\&s=e8b17b76b3f2a7a4b53bb75edd60b707)

Each turn is a card, newest first: the session and when it finished, its agent and branch,
its status and the start of the answer. Pick one to open its session's chat in the middle, scrolled
to that turn, marked by a line down its left, when its machine still lists the session and the
session still shows that chat; otherwise the turn opens there on its own (on a phone it takes the
screen, with a way back to the feed). [rakumux.com/feed](https://rakumux.com/feed), and its links to
a turn, open Sessions with the feed shown and that turn open.

A turn on its own is a card: its top border names the session, then the agent and the branch it worked
on (its folder when there's no branch), with when it finished and its status on the right (on a phone,
those sit at the top inside the card). Hover over the time for the full date and the machine. Inside,
in order: what you asked, as your message; the turn's steps (its reasoning, each tool call as one
row you can click to see its input and output, failures marked, and what the agent said along the
way); then the agent's
answer, shown as Markdown (headings, lists, tables, code and links). A question the agent asked you
shows as its picker, with what you chose ticked once you've answered in the terminal. A turn whose
machine didn't send its chat shows the answer alone. Links open in a new tab, and only web and email
links work; images aren't loaded, only named with a link to them.

A prompt you sent that the agent is still working on shows as a card too, for up to 6 hours: your
message, the agent's steps so far as they arrive (its newest 50), a tool call it's still running
marked **Running…**, and **Waiting for the answer…**. When the answer arrives, the same card fills in.

| Status | Means |
| - | - |
| **working** | The agent hasn't answered your prompt yet. |
| **done** | The agent finished its turn, and nobody wrote back to it. |
| **sent** | Your newest reply to it is waiting for its machine to type it in. |
| **delivered** | Your newest reply is in the session; the agent is on it. |
| **answered** | The agent answered your newest reply; its answer is in the thread below. |
| **reply not sent** | Your newest reply couldn't be typed in, or waited over an hour. Its bubble says why. |

Rakumux's Feed says the same in its own words: **reply waiting**, **reply typed in**, **answered**
and **reply not sent**, or only the mark where the card's border is short of room.

New turns arrive at the top of the feed while it shows (it checks every 10 seconds while the tab is
in view, every 2 seconds while an agent's working card is moving; a turn shows up about 15
seconds after it finishes, once its chat has arrived). If you've scrolled the feed down, it stays where
you are and a **new** button at its top takes you up to them.
**Load older** at the bottom of the feed goes back 20 turns at a time. Texts show whole, and a tool's long input
or output scrolls inside its own box; a part over 16,384 characters, and a very long turn, are cut and
say so.

## Your sessions on the web

With the feed on, each machine also sends rakumux.com its list of sessions, so the web app's
**Sessions** shows them from every machine. The first row of its list groups them, as Rakumux's
tabs do: by **Status** ([rakumux.com/status](https://rakumux.com/status)), **Folders**
([rakumux.com/folders](https://rakumux.com/folders)) or **App**
([rakumux.com/app](https://rakumux.com/app)). The Rakumux logo takes you back to the grouping you
last used, Status at first, with the session you had open. That takes Rakumux 0.1.20 or later; a machine
sends its list when it changes and every minute.

* **Status** groups the sessions as Rakumux's Status tab does, in its order: waiting for you, unread,
  working, waiting for response, running, exited, then ready, each with its count and Rakumux's mark,
  the most recently used first.
* **Pinned** sessions sit in their own section at the top of Status, Folders and App, above every
  status, folder and app, as in Rakumux's list.
* **Folders** groups them by folder, as the Folders tab does, with the folder's branch and how many
  of its sessions are running; with more than one machine, each machine's folders sit under its
  name.
* **App** groups them by the app they run, as the App tab does: agents first, then other programs,
  then shell, each with how many of its sessions are running. Programs other than agents need
  Rakumux 0.1.21 or later; an older machine's sessions without an agent are under shell.

Drag a session to put it in your own order within its folder, app or status, or the pinned section
(ready stays in order of last use): with the mouse, a long press on a phone, or **Alt+↑/↓** on a
focused row. The order is saved to your account, the same in every browser, apart from each
Rakumux's own.

With more than one machine, **▣ All machines ▾** in the header, beside the logo, picks which
machine's sessions the list and the Feed show: all of them, or one. Its menu lists each machine with
how many sessions it has, and how long it's been away when it is. This browser remembers your choice.

![The machine switcher in the header, beside the logo, open over the session list: All machines, then devbox, laptop (away 3h) and studio, each with its number of sessions](https://mintcdn.com/human-unsupervised-pty-ltd/0vQlovgyyhEkGszX/images/web-machines.png?fit=max\&auto=format\&n=0vQlovgyyhEkGszX\&q=85\&s=652c423ba89a5eee377a4e083ac3e639)

Each session shows its name, the app it runs and how long ago you last used it, and under them, on
one line, where it works now: its folder or worktree, then its branch. When it has changed files in
other places too, **▸** left of that line opens them (**▾** closes them), each a step further in,
under a rule: its name, then its branch and how long ago the session worked there, most recent first.
Opening them never opens the session, and they close again when you reload the page. Places need a Rakumux release that sends them, on that machine;
until it runs there, a session shows only where it works now. A machine that hasn't sent its list for 3 minutes is marked **away**: what it
says about its sessions may be out of date. Dead sessions and private ones aren't listed.

Select a session to open its chat beside the list (on a phone, the chat takes the screen, with ‹ to go
back). On a wider screen, opening Sessions with no session open selects the first one in the list.
The page's address names the session, so a link opens it, and switching the grouping keeps it
open. The chat reads like the feed: your
messages, the agent's answers as Markdown, and all its reasoning and tool calls between them (while
the agent works, a tool call still running says **Running…**).
New messages arrive while it's open (it checks every 5 seconds while the tab is in view, every 2
seconds while the agent works) without moving you; scrolling up loads older ones. A session's chat shows once its machine has sent it, so
only Claude Code, Codex and OpenCode sessions have one.

![rakumux.com on a phone: the session list with places, a session's chat with a reply and an attached screenshot, and the Feed](https://mintcdn.com/human-unsupervised-pty-ltd/0vQlovgyyhEkGszX/images/web-mobile.png?fit=max\&auto=format\&n=0vQlovgyyhEkGszX\&q=85\&s=a83b42666cf5d61f3b77e2de85e9de34)

At the bottom, write to the agent. With an answer in this chat, it goes to the newest one, as a
**Reply** on the feed does, and the same rules apply (below). With none yet (a new chat, or the
session's newest answer is in another of its chats), it goes to the session itself: its machine
types it in once the agent waits for you, whichever chat it shows, and the agent's answer starts a
new turn in the feed. Rakumux 0.1.21 or later takes these on your machine. What you write shows in
the chat with where it is up to; one the machine typed in shows on your message in the chat. The
box says when you can't write: no agent runs in the session, or it has ended. When the machine is
away, it says so; what you write waits for it up to an hour.

## Reply

You can write back to an agent from its turn in the feed: the box at the bottom of its session's
chat on rakumux.com, **Reply** under the turn when it opens on its own there (`Enter` sends,
`Shift+Enter` starts a new line, up to 8,192 bytes), or `r` on the turn in Rakumux's Feed. Rakumux on the machine that ran the session
types your reply into it, as if you had typed it there, and the agent's next reply answers it.
Under the turn you replied to, its thread shows each reply with where it's up to; once the
agent answers, the reply and its answer become one card, the reply at its top. A reply to an answer
joins the same thread. A turn whose machine didn't say which
of the agent's chats it belongs to (older versions of Rakumux) has no **Reply**.

You can only reply to a session's newest message: its latest turn, whether it shows on its own or as
an answer in a thread. Older turns of the same session have no **Reply**, and when a newer one arrives while you're
writing, sending is turned off and the box says so, keeping your text so you can copy it to the newer
turn.

The machine types a reply in only when:

* the session is still running there, and isn't private;
* it still shows the same chat (a session that moved on to another conversation doesn't get it);
* the agent is waiting for you: it has finished its turn or is idle, never while it's working or
  asking for permission, where your text could answer the agent's question;
* nobody has typed in the session on that machine for 10 seconds, so your reply isn't added to what
  someone is writing there (Rakumux 0.1.21 or later). Text left unsent in the agent's prompt is still
  sent along with it.

Until then the reply shows as **Sent**, and as **Delivered** once it's typed in. Each machine checks for replies
every second while a reply waits for it, while rakumux.com is open in front of you, and for half a
minute after you write a reply anywhere (on rakumux.com, your phone or another machine) or one is
typed in. As your replies go quiet it checks less often, down to every 15 seconds after 4 minutes.
A reply still waiting after an hour isn't typed in. One that can't be typed in says why: the
session ended, shows another chat, is private, or the machine doesn't take replies written
elsewhere.

### Allow replies on a machine

A reply is input to an agent that can run commands, so each machine decides whether it takes
replies written somewhere else. In Rakumux on that machine, turn on **Settings → Available on
sign-in → Replies from rakumux.com**. It's off by default and can only be turned on from that
machine, never from the website. Without it, replies written on rakumux.com or on another of your
machines aren't typed in and say so. A reply written in a machine's own Rakumux to one of its own
sessions needs no setting.

### Attach files

On rakumux.com you can attach files to a reply or to a message to a session: the paperclip beside
**Send**, files dropped on the box, or files pasted into it (a screenshot, say; pasting text works as
always, dictation apps included). Up to 5 files of at most 4 MB each, of any kind. Each one uploads
as soon as you attach it, shown under the box with a thumbnail for pictures and its progress; **Send**
goes at once, and the message waits for its files. A message with files and nothing written says
"Here are the attached files."

Rakumux on the machine the message is for fetches the files before typing anything, saves them in
`~/.rakumux/uploads/` (in a folder for that message, kept 7 days) and types your message followed by
each file's path, so the agent can open them. When a file can't be fetched, nothing is typed and the
message says so. Attaching needs a Rakumux release that fetches files, on that machine: until it runs
there, the box says **Update Rakumux on *machine* to send files.**

rakumux.com keeps a file only until its machine has it: its contents are deleted as soon as the
message is typed in or fails, or after an hour if it never is, and a file you attach but don't send
is deleted after an hour. Its name stays with your message, so the thread still shows what you sent.

## Turn it on or off

The agent feed is **off by default**. Turn it on, or off again, in Rakumux under **Settings →
Available on sign-in → Agent feed** (greyed out until you sign in), or at
[rakumux.com/features](https://rakumux.com/features). Both change the same switch on your account.
Turning it off or signing out empties the feed on that machine, and while it's off
rakumux.com doesn't show it. Turning it off also deletes your machines' session lists from
rakumux.com.

## What's sent, and where

| | |
| - | - |
| **What** | The whole chat of each Claude Code, Codex and OpenCode session: your messages to the agent, its replies and visible reasoning, the tools it runs with their input, and the tools' output (each piece up to 64 KB), plus each finished reply. With them: the session's name, its folder's name (never its path), the git branch the agent worked on, the agent, and this machine's name. Never a private session's. |
| **Cleaned first** | On your machine, Rakumux masks text that looks like a key, a credential assignment or a token. This is best-effort, so it can miss some. Tools' output can hold whatever the agent read or ran, such as parts of files and command output. |
| **Your session list** | Each machine's sessions now (never a private one): each session's name, its folder's name, the git branch its agent works on, the agent (or, without one, the program it runs, never a shell), whether it's running or has ended and what its agent is doing, the chat it shows, whether you pinned it and when you last used it; up to 8 places where it changed files (git checkouts and worktrees), each by its name or its path in the session's folder (never a full path), with its branch and when it last worked there, never the files or their changes; and when the machine last sent the list. Each list replaces the one before. |
| **Your session order** | The order you gave your sessions on rakumux.com: for each part of the list (a machine's folder, an app, a status or your pinned sessions), its sessions' ids and machines' names. |
| **Your replies** | What you write back to an agent or to one of your sessions (up to 8 KB), with the turn it answers (if any), the machine, session and chat it's for, the machine you wrote it on (none on rakumux.com) and whether it was typed in. |
| **Files you attach** | Up to 5 files of 4 MB with a reply written on rakumux.com: their contents only until the machine it's for fetches them (an hour at most), then their names, types and sizes with the reply. On that machine, in `~/.rakumux/uploads/` for 7 days. |
| **When you last used rakumux.com** | The time you last had the Status, Folders or App page (or the feed) open, noted at most every 30 seconds, so your machines check for replies every second while you're there. |
| **Kept** | On rakumux.com, 7 days after it arrives (a reply you write, 7 days after you write it), then deleted; 90 days while you have Rakumux Pro, and 7 again once it ends. A machine's session list is kept until its next one replaces it, and deleted when you turn the feed off or 30 days after the machine last sent one. Your session order is kept until you turn the feed off; a session leaves it once no machine lists it. When you last used rakumux.com is deleted a day later or when you turn the feed off. Deleting your account deletes it all at once. |

Rakumux 0.1.17 sends only the finished Claude Code and Codex replies.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.