Channels & the Record#

Most AI tools forget when you close the tab, and what they do remember lives on the vendor's servers. LIT keeps the record of the work — every message, every tool call, every file the agent wrote, every admin action — as files on your machine, under your identity. It belongs to you, not to whichever model answered last.

The unit of that record is the channel. History and capability are bound to it: what was said and decided, what the agent can do here, which files it can reach. Open it a month later, as a different person or with a different model, and the work is where you left it.

Channels bind history and capability#

A channel is a persistent, named workspace for one project: #contracts, #onboarding, #sprint-planning. Open it a week later and the agent knows where things stand — what was tried, what's decided, where you left off. You don't re-brief it. You continue.

Memory, skills, files, agents#

Couldn't remember. Each channel carries its own standing instructions — the production database is read-only, status updates stay short — its own memory file, and its own skills. Conventions hold without being repeated. The right tools are in the right room without configuring anything, and context compounds for as long as the project runs.

Channels are async. Send ten messages, send a correction, walk away. The agent catches up and answers when it's ready. A heartbeat agent posts its own cycles into the channel, and you reply from a phone at 6am.

Channels remember the matter; agents remember how. Bring the legal agent into #contracts and it finds the case files; bring it into #fitness and it brings its skills and none of the files. The room is the boundary: a team channel is shared with exactly the people who can reach its directory.

Pinned#

Some facts should never scroll away. Pin a message and it stays in the room across sessions, context limits and compaction: the current target, Tuesday's decision, the stakeholder's constraint. The agent carries pinned context forward automatically.

How channel memory is curated, and why it isn't RAG, is on Memory.

Backend-agnostic memory#

Couldn't change your mind. The history lives in the channel, not in the vendor's session. Switch the channel from Claude to Gemini to Codex and the next message picks up where the last one stopped: the new model reads the same transcripts, the same memory file, the same uploads. Replies carry an attribution header, so the record shows which model said what.

If one provider is having a bad day, you switch and keep working in the same room. Put a hard question to two models side by side and both answers sit in the record. Route #support to a cheaper model and #research to the strongest one, per channel. And when the next model ships, from anyone, it inherits months of context on its first message: the history was never the vendor's, so there is nothing to migrate. The model pool and per-channel overrides are on Any harness, any model.

Artifacts land in your sovereignty#

Couldn't keep what it made. When the agent writes a file, it writes it to your disk, in your directory, as you. The report it drafted, the script it fixed, the spreadsheet it built: real files under your permissions, not attachments inside a vendor's chat window that you copy out by hand. Model calls go out; the files, the channel and the record stay home.

The agent's output is where your other tools already look, and it is there tomorrow whether or not you renew with the vendor who produced it. Who the agent runs as, and what that bounds, is on Identity & security.

Tribal knowledge becomes institutional knowledge#

Couldn't find last month. Search across channels with Cmd/Ctrl+K and jump to the message in its history. The calendar view lays a channel's work out by day and hour, so what were we doing Tuesday afternoon? is a click. The knowledge graph links messages to the concepts, people and products they mention, so a topic is a node rather than a query. Keyword, time, or topic: three ways into one record.

The reasoning behind a decision usually lives in one person's head. In a channel it is in the room, searchable by whoever joins next — including after the person who decided has left.

A channel that's finished can be archived. Archive a work-session channel and a summary posts back to its parent; unarchive it and everything is back, because nothing was deleted.

The record is files#

Couldn't take it with you. On disk a channel is a directory: channel.json, an index, and messages/2026-09-09/001_in_ben.md, one markdown file per message, with pins, memory, journal entries and knowledge-graph tags beside them. An agent's turns are files too. For Claude Code sessions, the harness's own JSONL transcript is the ground truth — every assistant message, every tool call and result, token counts, and a definitive end-of-turn marker — and LIT persists from that stream rather than scraping a terminal.

You can grep your record. You can back it up with rsync. There is no export step because there was never an import.

Full visibility: audit and transcripts#

Couldn't see what it did. Tool calls stream into the channel inline as they happen: the file read, the command run, the result. The transcript afterwards is the same stream.

Every reply also carries its own receipt in the header: time to first byte and first content, the model that answered, and input and output tokens. The cost of a conversation is visible while you are having it, not at month end. Chat interface →

Two records, two owners. The channel transcript — what was said and done — lives in the member's home, and admins don't read it by default. The audit log and usage ledger — who dispatched what, when, with which model and seat, and every admin action — are written by the service account under the platform's config dir, append-only, so a member's own agent can't rewrite them.

The Audit tab filters by user, agent, channel, model, date and action. Exports are CSV or JSONL with a custodian filter; that file is what your SIEM or WORM store ingests. Budgets, allow-lists and the kill switch are on Seats & Policy.

Reading a transcript: grants#

Couldn't investigate without a backdoor. An admin who needs to read a member's channels opens a grant: one member, a reason, a window of hours (72 by default; the policy sets the cap). Every read inside the window is an audit row. The member sees the grant on their own policy view — ben may read your channels until 7:25 PM — support ticket 41. An owner can open a quiet grant for an investigation: still audited, not shown. Grants expire on their own; revoking ends one early. One live grant per admin per member.

Retention and holds#

A retention period on the policy bounds the audit log and usage ledger. A daily sweep drops older rows and writes the prune into the log itself, so the record always says what left it and when. A legal hold on a person exempts every row that names them, keeps their data through offboarding, and flags their rows in every export. Channel transcripts stay in members' homes and are not swept.

When someone leaves#

Couldn't be handed off. Institutional knowledge is only institutional if it survives the person. When someone leaves — by an admin's action, or automatically when the identity provider disables the account — one operation runs, every step on the record: their agents stop, their team membership and credentials are removed so the account can't return through SSO, and their agents and channels move to a successor, a person or group named per person in the policy, with a team-wide successor as the fallback.

The channels arrive intact: history, memory, pins, files. Transferred agents arrive with their heartbeat off; the successor decides. They are told in the first channel they received — who left, what moved, who did it — on the record, not in an email. What wasn't transferred is archived after a set number of days into a service-owned tarball; a legal hold keeps the source. Reinstating reverses the access part; what moved stays moved, and the record says where.