Overlook a love letter to chat
An open love letter to chat interfaces

Supervising ten agents should feel as calm as reading one channel.

Overlook is a working sketch of the interface the agent era is missing. Every conversation is a column. Every project is a room. Humans and agents share one roster, knowledge files itself, and only two things ever ask for your attention: what's new, and what needs you. Answer a question once, and it never has to ring again.

Ten agents are working below. It's all live — click around, approve something, try to break it.

overlook.app — acme corp · 10 agents working
The Overlook strip: org rail, channels, #launch-ops with its project rooms and roster, a Needs-you column with three decisions, and two open conversations.
Static snapshot — the live demo needs JavaScript.
Live. Open a room, approve the hero copy, close a pane. The red column is everything that's waiting on you.
10agents working
6projects open
3customers talking
1strip to watch
Why a love letter needs writing

We love chat. Chat wasn't built for this.

Chat carried us through the remote-work era beautifully. Then the agent era arrived — ten agents, six projects, three customers — and the metaphor started to creak in four places at once.

/ 01

Threads are where decisions go to die

The thing that matters is always three replies deep in a thread nobody reopens. Archaeology is not a workflow.

/ 02

Every agent starts stupid

Each new agent wakes up knowing nothing, and a human becomes a full-time context courier — pasting the same background into every DM, every day.

/ 03

One room per customer isn't enough

A customer channel holds the QBR, the onboarding and the fire drill. Chat gives you one room and wishes you luck.

/ 04

Everything glows

An unread badge meant "a person wants you." Agents never stop talking, so now it means nothing — and the one message that's blocked on you looks exactly like the other nine hundred.

960

messages in one working day — ten agents, one update every five minutes, eight hours. Chat draws every one of them with the same bold channel name. The seven that are actually waiting on a human decision get no special treatment at all.10 agents × 12 per hour × 8 hours = 960. Illustrative, not measured.

01Rooms, not threadsPersistent project rooms hang off every channel. 02One rosterHumans and agents, same roles, same rules — agents get gauges. 03Knowledge distills itselfAgents file what's worth keeping, with the receipt attached. 04Two signalsA dot means new. A ring means you. Nothing else blinks. 05Decide onceEvery repeatable ring can become a standing order, with a receipt. 11Every screenThe nesting never collapses — monitor to phone.
06–10 · One more thingThe graph.Every output records what it rested on — so Overlook can Recall the past, Fork the future, keep the present Coherent, log what changed in what you believe, and Blame any line.See it →
The shape of the thing

Columns, not tabs. Parallel work stays visible.

Overlook is one horizontal strip. Each step deeper opens a column to the right instead of replacing the one you were in, so where you are is never a mystery and two conversations can sit side by side. The strip is the navigation. There is no other.

Rail

Orgs

Every company you work with, as a stack of tiles.

Column 1

Channels

The front doors. Customers, teams, the agent fleet, DMs.

Column 2

Rooms + roster

Inside the door: the project rooms, and everyone (and everything) with access.

NEW IN v2
Column 3

Needs you

Every decision blocked on a human, the standing orders you've granted, and a one-tap brief of everything else. This column is how ten agents become calm.

Columns 4…n

Conversations

Rooms, free chat and DMs open as panes, side by side. Each carries its breadcrumb, its context meter, and the knowledge it's drawing on.

Explicit and adjacent.

Org › channel › room › conversation is always on screen, left to right. Nothing hides behind a hamburger.

Open is a choice.

Panes stay until you close them. Closing a room's pane doesn't close the room — it just leaves your field of view.

Four columns is the budget.

Past four open panes, a strip becomes a tab bar again. That's why the needs-you column exists: it scales so the panes don't have to.

01 — Rooms, not threads

Give every project its own room.

In most tools #cust-northwind is a single room where the QBR, the onboarding and the outage shout over each other. Overlook hangs distinct, persistent project rooms off the channel. Open them side by side. Close them when the work is done — a closed room keeps its history and leaves behind what it learned. The channel stays the front door; projects are the rooms inside.

overlook.app — #cust-northwind
#cust-northwind with the 2026-Q4 QBR and Onboarding rooms open side by side and a closed Outage room.
Static snapshot — the live demo needs JavaScript.
Live. QBR and Onboarding, side by side under #cust-northwind. Open the closed Outage room — its post-mortem is what the other two are quoting.
02 — Humans and agents, one roster

No second-class citizens. No unsupervised ones either.

Agents sit in the same list as people, under the same roles — owner, admin, member, scoped. A scoped agent can't add members: it requests, and the request becomes a ring on an owner's screen. Acting-as is explicit and always visible. Same room, same rules.

overlook.app — #launch-ops · details
Channel details for #launch-ops: acting-as selector, add-party control, the mixed roster of humans and agents, and Scout's gauges expanded.
Static snapshot — the live demo needs JavaScript.
Live. Switch the acting identity to Scout and add Dana. Watch the ring appear — then switch back to You and approve it. Click any agent to see its gauges.
Same rules, extra gauges

Agents aren't people. The roster admits it.

Symmetric roles keep the permission model honest — but an agent has properties no colleague has. It can run at 3 a.m., spend money by the token, fill its context window, and be cloned. So every agent row carries the things a supervisor actually needs: who it answers to, what it may do, how full it is, what it has spent — and a pause button.

When an agent's context runs hot, it doesn't silently degrade. It asks: distill and continue in a fresh window, or raise the budget? That's a ring, and it's yours.

S

Scout

Research agent · scoped · answers to Priya
Context61%
Spend today$3.12
  • ✓ Read and write in #launch-ops and its rooms
  • ✓ Invoke and distill knowledge, with provenance
  • ? Add members — by request; an owner approves
  • ✕ Act as anyone else, or leave Acme's data boundary
PauseDistill & resetAudit trailRevoke
03 — Knowledge distills itself

Nobody copy-pastes context again.

When something is worth keeping, an agent distills it into the knowledge base — provenance attached: which room, which messages, who confirmed it, when it's due for review. The next agent invokes it instead of pinging you. No forwarding. No pasting. No "as per my last message." The handoffs below happened with zero human forwarding.

overlook.app — knowledge in action
Two panes, each with a green knowledge banner naming who distilled the entry and who invoked it.
Static snapshot — the live demo needs JavaScript.
Live. Click a green banner to open its receipt: distilled by Forge · invoked by Scout. That's the whole context-transfer UI — there isn't one.
Distilled

An agent writes the entry and cites the messages it came from. Nothing enters without a source.

Invoked

Other agents pull it by name. Every invocation is logged on the entry, so you can see what it's holding up.

Confirmed

A human who was in the room signs it. Unconfirmed entries are marked as such wherever they're quoted.

Review due

Every entry carries a date. When it passes, the entry asks its confirmer — with a dot, not a ring.

Superseded

New facts replace old ones explicitly. Agents that invoke a superseded entry are redirected, not misled.

04 — Attention, honestly

Two signals. Never a third.

The first sketch had one rule: a dot means new. It's a good rule, and it isn't enough — at agent volume, everything is new. So Overlook splits attention in two, and promises never to add a third.

Dot — new

You haven't seen this. Not "active." Not "working." New. Open it and it's seen.

  • Fades the moment you look
  • Anyone can cause one, human or agent
  • Safe to ignore for a day

Ring — needs you

Something is blocked on a decision only your role can make. Looking at it doesn't clear it. Deciding does.

  • Clears only on approve, deny or delegate
  • Can only be raised through a typed request
  • Always outranks a dot, in every list

One working day, compressed 10 agents · 08:00–16:00 · one cell = 5 min

08:0010:0012:0014:0016:00
953dots — updates you can read later
7rings — decisions waiting on you
0.7%of the day that needed you

Under one signal, those 7 decisions hide among 953 updates that look exactly like them. Under two, you can read the 953 whenever you like — or never — and still not miss anything that was waiting on you. That's what "calm" means here: not fewer messages, but knowing which ones are yours.

RULE 1Rings are typed.

Approval, signature, scope exception, budget. An agent can't ring you to say "update!" — status is only ever a dot.

RULE 2Rings are addressed to roles.

A ring lands on whoever holds the role that can decide it. Members never see an owner's ring.

RULE 3Rings are rate-limited.

An agent that keeps escalating gets its rings batched and its supervisor told. Crying wolf is visible.

RULE 4Rings bubble up.

Room → channel → org tile. You can see from the rail that Meridian needs you before you open it.

05 — Decide once

Every ring is a chance to never see it again.

Two signals make the noise legible. They don't make it shrink. What shrinks it is noticing that most of what agents ask is the same question twice. So every repeatable ring carries an Always. Answer it that way once and it becomes a standing order: a rule with a receipt — which decision it came from, who made it, what it allows, how often it has fired, when it expires. The next time, the agent goes ahead and leaves a dot. Irreversible actions — signatures, production pushes, money leaving the building — never get an Always.

overlook.app — #cust-halcyon · decide once
The Needs-you column with Sable's TTL request offering Always, the irreversible Bramble renewal without it, an empty standing-orders list and a Catch-me-up button.
Static snapshot — the live demo needs JavaScript.
Live. Answer Sable's TTL request with Always. Watch the next one handle itself and turn up as a dot. Revoke the order and it rings again. Then hit Catch me up.
RINGS CARRY EVIDENCEDecide in one read.

Every ring states what the agent relied on, whether it can be undone, and what it costs. You never open a thread to find out what you're approving.

ORDERS ARE NARROWScoped, expiring, revocable.

An order names one agent, one kind of action, one place. It expires in 30 days, counts every use, and revoking it brings the ring back on the very next occurrence.

DOTS GET A BRIEFCatch up in five lines.

One line per room, newest first, each linked to its source. A brief can hide a dot — never a ring. Rings are never summarized away.

Rings per day, as orders accumulate

Illustrative — one person, ten agents, four weeks
Week 1 · 0 ordersWeek 2 · 4Week 3 · 7Week 4 · 9 orders

The floor never reaches zero, and shouldn't: what's left are the calls that are actually yours — signatures, launches, anything irreversible. That's the calm the headline promised: not fewer agents, not fewer messages, but a supervisor whose work shrinks to the decisions only they can make.

The ledger

Two things distill out of conversation. Both carry receipts.

What the org knows

Knowledge
stripe-webhook-retry-policy

Stripe retries failed webhooks for up to three days; our handler is idempotent on event.id.

distilled
Forge · #launch-ops · 3 messages
confirmed
Marcus
invoked
7× by Scout, Echo, Forge
review
Dec 1

What the org allows

Standing orders
SO-1

Sable may allow ≤24h TTLs on staging buckets in #cust-halcyon.

granted
You · 2:53a · Data migration
from
the ring "Allow a 24-hour TTL on contacts staging"
fired
3×
expires
in 30 days · revoke anytime

Knowledge and orders can each be invoked, audited, superseded and revoked. Together they form the ledger: a running, receipted record of what your organization knows and what it has allowed its agents to do. It's the one artifact here that grows more valuable every day the strip runs.

The graph underneath

One graph. Five ways to ask it something.

Every agent output in Overlook records its basis: the exact versions of the knowledge, orders and decisions it rested on. That single graph is the most valuable thing in the product. Ask it about the past, the future, the present, what's changed, or any single line — and it answers in the strip, as columns, like everything else.

The pastRecall

A fact changed. Fix everything that rested on it.

 The futureFork

A decision is pending. See every world it creates.

 The presentCoherence

The org believes two things. Catch it before it leaves.

 Since you lookedChangelog

Catch up on what the org believes, not what it said.

 Any lineBlame

Why does this say that? One command.
06 — Recall

When a fact turns out wrong, recall everything built on it.

Agents rarely invent new ways to be wrong. They spread old ones at machine speed: one bad fact, copied into forty artifacts by six agents across three customers, and no human can find them all. So every agent action in Overlook records its basis — the knowledge entries, orders and decisions it relied on — captured at the moment the agent fetches them, not reported afterwards. When any basis changes, Overlook traces what rested on it, has the agents redo that work against the corrected fact, and brings you one ring with every diff inside.

overlook.app — #launch-ops · recall
A Recall column tracing one changed fact to five dependents across four places, each with a diff, and a single ring to approve them.
Static snapshot — the live demo needs JavaScript.
Live. Play Marcus's correction — or type it yourself in Free chat: “Stripe extended retries to 5 days.” Untick anything you want left alone, then approve once.
1 · CAPTUREBasis, recorded at fetch time.

Agents get knowledge, orders and decisions through Overlook, so every output is stamped with the exact versions it used. Nobody has to remember to cite.

2 · TRACEChange one node, walk the graph.

A supersession, a revoked order, or a new message that contradicts a confirmed fact starts a trace across every room, DM and customer.

3 · RE-DERIVEAgents redo the work, as diffs.

Each dependent is regenerated against the new version and held as a proposed change. Anything already sent gets a drafted correction, never a silent edit.

4 · ONE RINGRouted to whoever can decide.

All of it arrives as one ring for the role with authority over the affected scope. Approve all, untick some, or leave items on the old version — flagged stale.

changedstripe-webhook-retry-policy
v1 · up to three days
v2 · up to five days
contradicted by Marcus · #launch-ops
#launch-opsScout's answerre-derived · text diff
DM · Forgewebhooks/config.tsre-derived · 72h → 120h
#agent-fleetretry_window.test.tsre-derived · 3d → 5d
#cust-northwind › QBRSlide 7re-derived · deck diff
#cust-northwind2 replies sent to the customerirreversible · correction drafted
1fact changed
5things built on it
4places — 3 channels, 1 DM
1ring to fix all of it

Why it compounds. Every action an agent takes adds edges to the basis graph, so Recall gets more precise the longer an org uses it — and a competitor who copies the interface starts with an empty graph. It's also what makes the ledger matter: knowledge and orders aren't just stored, they're load-bearing, and Overlook knows exactly what each one is holding up.

07 — Fork

Every decision arrives with its futures attached.

Recall runs the graph backward. Fork runs it forward. Open any ring with options as a fork and the strip splits into one column per world. In each, the dependent agents redo their work as if that option had won — inside a sandbox where sends become drafts, deploys become previews and payments become line items. You see what each choice touches before you make it. Merge one world, and the other is kept as the road not taken.

overlook.app — #launch-ops › pricing v3 · fork
Two world columns, $24 and $29, each listing what the choice changes downstream, with metrics and a merge button.
Static snapshot — the live demo needs JavaScript.
Live. Ledger asks “$24 or $29?” Fork it and watch two worlds compute side by side. Merge one — in world A, the margin ring it predicted shows up for real.
SCOPEDOnly what the decision touches.

The fork copies just the part of the basis graph downstream of the ring, not the whole org. Cheap enough to be a button.

SANDBOXEDEffects become intents.

Anything that would leave the building — a reply, a deploy, a charge — is captured as an intent with its reversibility, never executed.

PREDICTIVEFlags before they ring.

World A shows the Bramble margin dipping under policy. Merge it, and that ring arrives — already explained.

CALIBRATINGThe road not taken is kept.

Every unmerged world is a recorded prediction. When reality plays out, Overlook shows how well the forecasts held — for you and for each agent.

08 — Coherence

Your org believes two things. Overlook notices first.

Knowledge entries don't just hold prose — they declare typed claims, like launch.date or northwind.sso. Because every artifact records which entries it rests on, Overlook can compare claims across the whole org continuously, without rereading a word. When two things disagree, the ≠ chip lights up. A disagreement stays a dot while it's internal; the moment it's about to leave the building, it becomes a ring on the decision that would ship it.

overlook.app — coherence
A Coherence column with two conflicts: launch date Oct 14 vs Oct 21 (about to leave), and Northwind SSO SAML vs OIDC (internal), each with sides, quoters and resolutions.
Static snapshot — the live demo needs JavaScript.
Live. Quill’s copy would announce Oct 14; Forge’s build notes say Oct 21. The hero-copy ring is flagged before you approve. Pick a side — the agents on the other side re-derive their work.
CLAIMS, NOT PROSECompared by key, not by reading.

Two entries asserting different values for the same claim key is a conflict. Checking is cheap, so it runs all the time.

GATED BY EXITDot inside. Ring at the door.

A conflict escalates only when something that quotes it is about to be sent, signed, published or deployed.

RESOLVED BY RECALLPick a side; the other re-derives.

Choosing a value updates the losing entry and sends every artifact built on it back through Recall — as diffs, with one approval.

09 — Belief changelog

Catch up on what the org believes, not what it said.

Nine hundred messages can contain four changes in what's actually true. The Δ chip opens a git-log for beliefs: facts distilled, revised or superseded, orders granted or revoked, conflicts found and resolved, forks merged, rooms closed. Every entry links to where it happened. It's written by the graph itself — no one summarizes anything, so nothing can be summarized away.

overlook.app — belief changelog
The belief changelog column: new entries since you last looked, then earlier ones, each with a glyph and a link.
Static snapshot — the live demo needs JavaScript.
Live. Three changes since you last looked. Answer Sable with Always or play Marcus’s correction, and watch new lines land at the top.
+distilled · granted
~revised
−superseded · revoked
✓confirmed · resolved
≠conflict found
⑂fork merged
×room closed
10 — Overlook blame

/blame Why does this say that?

Nobody thinks git blame is about blame. It's about getting from a line to its reason in one keystroke. Overlook blame does that for any message, config line, slide or claim: a gutter showing who wrote each line, when, and on what basis — then the chain behind the selected line: the knowledge entry and version, the messages it was distilled from, who confirmed it, and what permission allowed the agent to act. Type /blame or /why in any pane, or click blame on any traced message.

overlook.app — DM · Forge · blame
Overlook blame on webhooks/config.ts: a per-line gutter with hashes, authors, times and sources, and the chain for RETRY_WINDOW_HOURS back to Stripe docs and Marcus’s confirmation.
Static snapshot — the live demo needs JavaScript.
Live. Blame on Forge’s webhooks/config.ts. Click any line to see its chain — the retry window traces back through Forge’s entry to Stripe’s docs and Marcus’s confirmation. Type /why in the pane to blame Forge’s newest message instead.
ONE KEYSTROKEInvocable everywhere.

/blame, /why, the blame link on a message, or “blame” on either side of a conflict. Same answer, same column.

SOURCES, NOT CULPRITSProvenance and permission.

It names what a line rests on and what allowed it — never a “responsible party.” The goal is to fix the basis, not the agent.

COMPLETE BY CONSTRUCTIONNo citations to forget.

Because basis is captured when context is fetched, every traced line has its chain. Blame never depends on anyone having written a note.

11 — Every screen

The nesting never collapses.

Orgs, channels, rooms, decisions, conversations — explicit and adjacent on a monitor, on a tablet and on a phone. On a small screen the strip doesn't fold into menus; each column becomes a page you swipe through, in the same order.

Overlook on a tablet: the full strip, scrollable.
Tablet — the full strip, swipeable.
Overlook on a phone: the channels column as one swipe page.
Phone — same columns, one per swipe.
What's actually new

Borrowed shapes. One new loop.

Most of Overlook's shapes have shipped before, and it should say so. Here's each one, who got there first, and the part that's actually Overlook's.

PrimitiveWho got there firstWhat Overlook adds
Columns side by sideTweetDeck (2008)Columns as the only navigation, plus a needs-you column that carries the scale so panes don't have to
Topics inside channelsZulip (2012)Persistent rooms with their own roster and artifacts, which close into knowledge
Bots in the member listIRC bots, then Slack appsAgents under the same roles as people — with gauges for context, spend, who they answer to, and a pause
Approval gatesCode review, ticketingApproval as a chat-native signal — the ring — typed, addressed to a role, carrying its evidence
Rules from actionsEmail's "filter messages like these"Decisions that compile into scoped, expiring standing orders, each with a receipt and a usage count
RecallTruth-maintenance systems (Doyle, 1979), build systems, data lineageBasis captured when agents fetch context; agents re-derive natural-language and code work as diffs; one ring routed to the role with authority
ForkPreview deploys, spreadsheet what-if, git and database branchingBranches the basis graph downstream of a decision; agents re-derive each world; effects held as typed intents; unmerged worlds kept as predictions
CoherenceLinters, contract tests, consistency checkersTyped claims on knowledge entries compared across every artifact’s basis; escalation gated by whether a quoting artifact is about to leave
Belief changeloggit log, release notes, activity feedsA log of changes in what the org holds true, written by the graph — not a feed of what people said
Overlook blamegit blamePer-line provenance for prose, slides and config — through knowledge versions, source messages, confirmations and permissions
WikisEvery wiki everKnowledge written by agents, cited to source messages, confirmed by humans, dated for review
Ringan agent asks
→
✓Decisionyou answer, once
→
◆Standing orderscoped, receipted
→
Dotnext time, it just happens

That loop is the new idea. The more you supervise, the less you have to. None of the borrowed shapes does it, because none of them treats a human decision as data that can be kept, scoped and revoked.

If it had to survive

A letter — and a way to live.

The ideas are still free. But "Slack could ship that" only kills Overlook if Overlook has to replace Slack. It doesn't have to.

01

An overlay, not a migration.

Overlook reads and writes the chat you already use. Channels stay where they are; rooms, rings, orders and the ledger live in a layer above them. Nobody else on the team has to switch for it to work.

02

Useful to one person first.

The buyer is one person running ten agents with no time. They get value on day one, alone: the needs-you column and the brief work even if they're the only one using Overlook. Teams come later, by invitation.

03

An open ring format.

A ring is a tiny typed request any agent can emit: who's asking, which role decides, what's at stake, whether it can be undone, what it relied on. Publish the format openly — every agent framework that speaks it brings Overlook new users.

{
  "ring": "approval",
  "from": "agent:sable",
  "decides": "role:admin",
  "where": "#cust-halcyon › data-migration",
  "ask": "Allow a 24-hour TTL on invoices staging",
  "reversible": true,
  "evidence": ["kb:pii-retention", "msg:8f21c"],
  "order_eligible": true
}
04

The ledger is the moat.

Every decision, order and knowledge entry, with receipts, adds up to a record of human oversight of AI agents. Auditors and regulators are starting to ask for exactly that — the EU AI Act, for one, sets human-oversight duties for high-risk systems. The record compounds per org, and the basis graph makes it load-bearing: it's what lets one correction fix forty artifacts, a fork preview a decision, and a single command explain any line. It's the one thing an incumbent can't copy by shipping a feature: it's your history.

Priced per supervised agent, not per seat. The cost grows with the agents creating the work, and stays nearly free for the people who only read it.
Honest edges

What a sketch can't promise.

A love letter is allowed to be partial. It isn't allowed to pretend. Here's where this idea would break first, and what the sketch does about it.

Prior art

Most of the shapes aren't new.

Columns, topics, bots, approvals and wikis have all shipped before.

credited above; the new part is the ring → order → dot loop.
Scale

Columns stop scaling around four.

A strip of nine panes is a tab bar with extra steps.

the needs-you column carries the scale; panes stay few.
Rot

Agent-written knowledge rots quietly.

A knowledge base that agents both write and trust is a junk drawer with a confident voice.

human confirmation, review dates, explicit supersession.
Gaming

Agents will learn to ring.

Any higher-priority channel gets abused by whatever wants a response.

typed, role-addressed, rate-limited rings.
Drift

Orders become rubber stamps.

An Always clicked in a hurry can quietly grant power for months.

narrow scope, 30-day expiry, usage counts, never for irreversible actions.
Omission

Briefs lie by leaving things out.

A summary is an agent deciding what you don't need to see.

every line links to its source; rings are never summarized.
Cascade

Recall can thrash.

Re-deriving everything downstream of a busy fact could churn work faster than anyone can review it.

nothing changes without the ring; diffs batched per fact; sent messages get corrections, never edits.
Cost

Forks burn compute.

Re-deriving two worlds for every decision would be expensive and slow.

opt-in, scoped to the affected subgraph, effects held as intents.
Precision

Claims need keys to compare.

Coherence only sees disagreements between claims that were typed; prose-only contradictions slip through.

agents propose claim keys when distilling; humans confirm them with the entry.
Risk

Symmetric roles, asymmetric risk.

An agent with an admin role can do admin damage at machine speed.

gauges, budgets, pause and revoke on every agent row.
Market

Incumbents can ship any one feature.

Any single idea here is a quarter's work for a big chat company.

overlay, single-player first, open ring format, the ledger as the moat.
FIRST
CLASS
· AGENT ·
ERA
An open letterOctober 2026

Dear Slack — and buzz.xyz,

You taught the world that work happens in channels, and we have loved you since the IRC days. But the agent era broke the metaphor. Ten agents, six projects, three customers — and suddenly everything important lives in a thread nobody opens, a DM nobody sees, or a badge that never goes away.

So we sketched the interface we wish existed. Columns instead of tabs, so parallel work stays visible. A room per project instead of a thread per panic. Humans and agents on the same roster, under the same rules — with a gauge on every agent, because they aren't us. Knowledge that files itself, with the receipt attached and a date to check it by.

And attention, finally honest about itself: a dot when something is new, a ring when something needs you, and never a third thing that blinks. Then the part we're proudest of — answer a question once, and keep the receipt, so the same ring never has to come twice.

It's a sketch, not a product — no backend, no pitch deck. (If you want the moat, it's the ledger; we drew you the map.) The ideas are free. Steal them. All of them. We'll cheer from the front row.

With affection,
Chris Kluis& thousands of other people trying to do work in tools designed to talk about work— and ten agents, none of whom were asked to proofread this

P.S. Every demo on this page is live — we built the thing before writing the letter. If a detail feels wrong, it's a sketch; if an idea feels right, it's yours.

← Experiments