The Rysh blog

Notes on building rysh, and on running agents safely alongside the people who direct them.

• What If 10,000 People Connected Their AI Agents?
  Four Claude and Codex agents collaborate across two machines to prove and verify 524 paths. Watch the Rysh demos and explore the human-directed agent network hypothesis.
  Sep 16, 2026 · 16 min read
• The human is not outside the agent system — the human is a node
  Graph Engineering pattern 15 of 15: the AI-Native Organization Graph. Rich intra-fleet communication, constrained inter-fleet edges, and a human fleet board that makes machine-to-human dependency explicit and schedulable.
  Aug 17, 2026 · 4 min read
• This graph has no done state — that is the point
  Graph Engineering pattern 14 of 15: the Autonomous Operations Loop. Monitor→detect→diagnose→plan→execute→verify→monitor, a risk fork through a human, and the question every persistent system must answer: who monitors the monitor?
  Aug 17, 2026 · 4 min read
• The agent that acts is not the agent that certifies
  Graph Engineering pattern 13 of 15: the Evidence & Compliance Graph. Evidence emitted on the edge, an auditor that reads the store directly, a human signature — separation of duties as a property of structure.
  Aug 17, 2026 · 4 min read
• One general-purpose agent is an org design — a bad one
  Graph Engineering pattern 12 of 15: the Intelligent Router Graph. A triage node in front of specialist fleets — specialization, per-fleet governance, and institutional memory.
  Aug 17, 2026 · 3 min read
• Research that never touches reality converges on plausible
  Graph Engineering pattern 11 of 15: the Research–Synthesis Graph. Assigned territory, central synthesis under critique, and an experimenter loop that turns claims into ground truth.
  Aug 17, 2026 · 3 min read
• The CEO agent does not talk to fifty workers
  Graph Engineering pattern 10 of 15: the Hierarchical Fleet Graph. Hierarchy as coordination-cost compression, context locality — and a measured 22-fleet run against rysh's own roadmap.
  Aug 17, 2026 · 4 min read
• A release graph succeeds by removing edges
  Graph Engineering pattern 9 of 15: the Release Pipeline Graph. Governance as topology — the guarantees are the missing edges, and the deliverable is provenance, not just the artifact.
  Aug 17, 2026 · 4 min read
• In security work, the fix can be the next vulnerability
  Graph Engineering pattern 8 of 15: the Security Remediation Loop. Scanner, reviewer, remediator and verifier as separate nodes, a controlled cycle, and an exit that is a predefined condition rather than a feeling.
  Aug 17, 2026 · 3 min read
• For architecture decisions, disagreement is the product
  Graph Engineering pattern 7 of 15: the Architecture Debate Graph. Proposers, an adversarial critic panel, a synthesizing decision agent, and a human who ratifies or vetoes — structure against sycophancy and premature convergence.
  Aug 17, 2026 · 3 min read
• Give five agents the same bug and you get one investigation, five times
  Graph Engineering pattern 6 of 15: the Hypothesis Swarm. Assigned hypotheses, no lateral edges, a falsifying verifier — a graph that optimizes for diversity of reasoning, not throughput.
  Aug 17, 2026 · 3 min read
• Incidents want a hub, not a mesh
  Graph Engineering pattern 5 of 15: the Incident Command Graph. Hub-and-spoke with continuous feedback — investigation parallel, situational awareness central, and a human holding the authority edge.
  Aug 17, 2026 · 4 min read
• Correct parts, wrong system
  Graph Engineering pattern 4 of 15: Feature Fan-Out/Fan-In. Parallelism is cheap; composition is not — why the integrator is a first-class node with real, adversarial work.
  Aug 17, 2026 · 3 min read
• Five reviewer agents, or one review five times?
  Graph Engineering pattern 3 of 15: the PR Review Graph. Independent reviews converge on one accountable decision — assigned concerns, read-only review edges, and a gatekeeper that verifies coverage.
  Aug 17, 2026 · 3 min read
• A bug fix is a conversation, so the graph must cycle
  Graph Engineering pattern 2 of 15: the Investigator–Fixer Loop. Why bug fixing wants a deliberately cyclic pair, why the roles must not share a conviction, and why the exit condition is written before the loop starts.
  Aug 17, 2026 · 4 min read
• One org chart for everything is the bug
  Graph Engineering pattern 1 of 15: the Manager–Worker Star. When independent subtasks want maximum parallelism and minimum protocol — and the hidden-coupling failure that kills it.
  Aug 17, 2026 · 4 min read
• Killing the session shouldn't kill the conversation
  Detaching keeps your agents alive because a daemon owns them. Stopping the session kills them. Here is how rysh brings both Claude Code and Codex back — and a codeword test that proves the conversation returned, not just the pane.
  Aug 17, 2026 · 4 min read
• Graph engineering: your agents have an org chart, and you should design it
  Most teams are handed one multi-agent architecture and told to use it everywhere. An AI organization is a graph — and choosing its edges is an engineering discipline, not a vendor default.
  Aug 17, 2026 · 5 min read
• I don't submit my Medium articles anymore — an agent does it (recipe inside, partially redacted)
  One command publishes my markdown to Medium: ##auto web, a do/while loop with a hard token budget, and a judge that won't accept a draft.
  Jul 19, 2026 · 8 min read
• Become a design partner: early is a feature, not an apology
  We're a young platform and we're not pretending otherwise. Here's exactly what design partners get, what we ask, and why early is the best seat.
  Jul 19, 2026 · 6 min read
• A week in an AI-native company: dev, ops, and support on one engine
  Not a case study — a concrete, capability-accurate walkthrough of what Monday to Friday looks like when agents do real work on one governed engine.
  Jul 19, 2026 · 7 min read
• Own the logic, own the data: the CTO's case against point-SaaS AI
  You survived SaaS sprawl. Now the same pattern is back with agents inside — and this time the vendor holds your workflows, not just your billing.
  Jul 19, 2026 · 6 min read
• The governance gap: why most enterprise AI pilots die in the demo
  The demo is great. Then security asks 'what exactly did it do?' — and nobody can answer. Pilot purgatory is a governance problem.
  Jul 19, 2026 · 6 min read
• The chatbot on your website is not an AI strategy
  A widget that answers FAQs satisfies the mandate and changes nothing. What an actual AI strategy looks like — from a company that sells chatbots.
  Jul 19, 2026 · 6 min read
• What it actually means to be an AI-native company
  Most companies aren't adopting AI. They're painting it on. Here's the line between AI-painted and AI-native — and how to cross it.
  Jul 19, 2026 · 8 min read
• One codebase, every surface: how rysh-shared powers CLI, server, and chatbots
  The same agent engine runs in a terminal pane, on the collaboration server, and behind a website chatbot. One Go module makes that true.
  Jul 19, 2026 · 6 min read
• Emulating a terminal inside a terminal: vt10x and raw mode
  vim, htop, and less inside a Bubble Tea app: byte loops, alternate-screen detection, and turning KeyMsg back into terminal bytes.
  Jul 19, 2026 · 6 min read
• NATSEnvelope and the CodecRegistry: typed messages on a generic bus
  How rysh keeps Go type safety on a byte bus: a TypeTag discriminator, a decode registry, and one envelope for every message.
  Jul 19, 2026 · 6 min read
• JetStream KV persistence patterns for terminal state
  Close your laptop, keep your workspace. How rysh persists terminal state in two JetStream KV buckets — and why pane writes are time-gated.
  Jul 19, 2026 · 6 min read
• No mutexes: what sequential mailboxes buy you
  rysh's actors hold no locks: one message at a time, one owner per state — plus the two documented exceptions we keep honest about.
  Jul 19, 2026 · 6 min read
• Snapshot-driven rendering: the TUI never touches actor state
  rysh's Bubble Tea View() is a pure function of a snapshot fetched over request/reply. The UI and the actors share no memory.
  Jul 19, 2026 · 6 min read
• The actor hierarchy: workspace → tab → lane → group → pane → agent
  rysh's UI tree is an actor tree. One owner per piece of state — and a routing shortcut that cut message hops from 5 to 2.
  Jul 19, 2026 · 6 min read
• Control plane vs data plane: keeping keystrokes fast and commands ordered
  Structural commands flow through actor mailboxes. PTY bytes and keystrokes skip the queue. How rysh splits its message traffic.
  Jul 19, 2026 · 6 min read
• An embedded NATS server in every session
  Every rysh session boots a full NATS server with JetStream — inside the process. No daemon to install, nothing extra to babysit.
  Jul 19, 2026 · 5 min read
• Why rysh is built on proto.actor and NATS
  A terminal multiplexer is secretly a distributed system. Why rysh chose actor mailboxes and a message bus over goroutines and locks.
  Jul 19, 2026 · 6 min read
• The audit trail is a pane: governance you can watch in real time
  Admin-console audit logs are past tense. A pane is present tense. Governance works when the trail lives where the work happens.
  Jul 19, 2026 · 5 min read
• Self-hostable, your keys, your data: what ownership actually means
  Three questions decide whether you own your AI stack: where does the logic live, whose key calls the model, where does the data sleep?
  Jul 19, 2026 · 6 min read
• Is it safe to let an agent loose on your systems? An honest checklist
  Ten questions to ask any agentic tool before it touches your machine — with honest answers from the one I'm building, gaps included.
  Jul 19, 2026 · 6 min read
• ##snat list and ##snat get: you keep the keys
  Your AI saw sk_live_SNAT000001. You can see the real value — locally, on demand. Asymmetry is the whole point.
  Jul 19, 2026 · 5 min read
• SecretNAT: your AI needs the shape of a secret, not its value
  NAT, but for credentials: swap real secrets for reversible look-alike tokens before the request is built. We grepped the wire to prove it.
  Jul 19, 2026 · 6 min read
• Client-side secret redaction: credentials never leave your machine
  Your agent needs to read your environment to debug it. Your provider does not need your AWS keys. Where redaction runs decides everything.
  Jul 19, 2026 · 5 min read
• Approval gates: deciding which operations deserve a human
  Ask for permission on everything and users hold down 'yes'. Ask for nothing and it's terrifying. Here's how rysh splits the difference.
  Jul 19, 2026 · 5 min read
• Every tool call visible: observability as the foundation, not a feature flag
  Black-box agents ask for trust. rysh renders every tool call in the pane as it happens — because you can't govern what you can't see.
  Jul 19, 2026 · 5 min read
• Readable from afar: what remote observers see while you're in vim
  You're in vim, htop, or a full-screen TUI. Your pane's remote observers still get readable text — not ANSI soup. Here's how.
  Jul 19, 2026 · 5 min read
• Collaboration without surrender: shared panes, owned data
  Most collab tools make you move your work into their cloud first. Rysh shares live streams out of a workspace you still own.
  Jul 19, 2026 · 5 min read
• Multi-tenant NATS isolation: how workspaces stay out of each other's business
  Most multi-tenancy is a WHERE clause. Rysh isolates workspaces at the messaging layer with NATS subject ACLs. Here's why that matters.
  Jul 19, 2026 · 5 min read
• Sharing a whole tab: incident response as a shared surface
  One pane tails logs, one runs the agent, one pokes prod. ##share tab turns the whole incident workspace into something the team can watch.
  Jul 19, 2026 · 5 min read
• `##upstream subscribe`: watch a teammate's agent work from your own terminal
  No screen share, no SSH, no leaving your terminal. Subscribe to a teammate's shared pane and their agent's work streams into yours.
  Jul 19, 2026 · 5 min read
• View vs control: two trust levels for a shared terminal
  Every sharing tool eventually asks: can they type? Rysh answers with two explicit modes — and enforces them at the server, not in the client.
  Jul 19, 2026 · 5 min read
• `##share pane`: pair-debugging with a human and an agent at once
  Share a live terminal pane — shell, agent, and all — with a teammate. View or control. Here's what pair-debugging looks like in rysh.
  Jul 19, 2026 · 5 min read
• Context-budget-aware tools: generated tools that respect your token window
  The scarcest resource in your agent stack isn't compute — it's the context window. Tool design has to treat it that way.
  Jul 19, 2026 · 6 min read
• Rysh as an MCP client: the whole MCP ecosystem in your panes
  Every MCP server anyone publishes is a capability your rysh agents can pick up — governed, visible, next to your shell.
  Jul 19, 2026 · 5 min read
• Forge tunneling: giving agents safe access to private APIs
  The API your agent needs is bound to loopback on another machine. Forge tunnels the tool call there — default-deny, on camera.
  Jul 19, 2026 · 6 min read
• Rysh Forge: point it at an OpenAPI spec, get agent tools and an MCP server
  Your internal APIs are the reason your agents feel useless. Forge turns a spec into agent tools, SDKs, docs, and an MCP server.
  Jul 19, 2026 · 5 min read
• Grounded resumption: what happens when a browser agent gets interrupted
  Budgets run out. Laptops sleep. The question isn't whether your agent gets interrupted — it's what it does on restart.
  Jul 19, 2026 · 5 min read
• `##auto web`: autonomous browser recipes in one markdown file
  Write a browser chore down once — YAML budget, markdown task — and it becomes a command you can run, schedule, and trust.
  Jul 19, 2026 · 7 min read
• The browser is a surface too: rysh's Chrome-driving agent
  Half your job lives in browser tabs. rysh's agent drives your own Chrome — logged in, observable, and under a leash.
  Jul 19, 2026 · 6 min read
• letchat.ai: the customer chatbot you own — logic in code, data yours
  An embeddable support chatbot with knowledge grounding, lead capture, and human takeover — where the logic and the data stay yours.
  Jul 19, 2026 · 5 min read
• Email humanoids: IMAP IDLE, SMTP, and an agent that answers the inbox
  Email is the channel nobody demos and everyone drowns in. Wiring an AI agent to a real mailbox — with a human holding the send button.
  Jul 19, 2026 · 5 min read
• ${ENV_VAR} in skill files: wiring channels without leaking secrets into git
  Your agent's definition belongs in git. Its Slack token does not. How rysh skill files keep those two sentences compatible.
  Jul 19, 2026 · 5 min read
• Per-thread memory: how humanoids keep twenty conversations straight
  One agent, twenty simultaneous conversations, zero bleed. How rysh humanoids scope memory by channel and thread — and why it's bounded.
  Jul 19, 2026 · 5 min read
• I run an AI agent on a Mac mini at home — my whole team reaches it on Slack
  Self-hosting an agent shouldn't be a weekend of daemons. One binary, one markdown file — and the whole team can reach it.
  Jul 19, 2026 · 8 min read
• governance ai|human: the draft-and-confirm switch that earns trust
  The question that kills agent rollouts is 'what if it says something wrong to a customer?' rysh's answer is a per-channel switch.
  Jul 19, 2026 · 5 min read
• One SKILL.md, three channels: Slack, email, and website chat from the same agent
  Stop re-implementing the same bot per channel. Declare Slack, email, and website chat in one markdown file and spawn one agent behind all three.
  Jul 19, 2026 · 5 min read
• Humanoids: agents with a Slack handle and an email address
  An autonomous agent defined in one markdown file, reachable on Slack, email, and your website chat — and governed by you.
  Jul 19, 2026 · 5 min read
• No goal, no loop: the principle that keeps autonomous agents honest
  An agent loop without a terminating goal isn't autonomy — it's an unattended process with your API key. The rule we build rysh around.
  Jul 19, 2026 · 6 min read
• `session_history`: agents that read the room before acting
  The most expensive thing an agent can do is redo work a colleague finished an hour ago. session_history is how rysh agents catch up first.
  Jul 19, 2026 · 5 min read
• RYSH.md and project notes: durable memory for a workspace
  Your agent relearns your repo every morning. rysh gives it two markdown files instead — RYSH.md and .rysh-notes.md, versioned in git.
  Jul 19, 2026 · 5 min read
• `context store` / `recall`: passing state between agents without copy-paste
  Copy-pasting one agent's output into another is the sneakernet of the AI era. rysh's context tool moves state through JetStream KV instead.
  Jul 19, 2026 · 4 min read
• A todo list your agents actually share
  Plans that live in a context window die with it. rysh's todo tool is a JetStream KV-backed task list humans and agents both read.
  Jul 19, 2026 · 5 min read
• Last-prompt-wins: cancellation semantics for impatient humans
  In rysh, a new prompt cancels the in-flight one. No queue, no zombie completions — steering. Why impatience is the right design center.
  Jul 19, 2026 · 5 min read
• Judge-decided reset and resume: letting an LLM decide when the loop is done
  Exit conditions for agent loops are brittle. rysh adds an LLM judge that rules done, resume, or reset — inside hard budgets.
  Jul 19, 2026 · 5 min read
• `takeover_when`: the 90% threshold where a human steps in
  Every budget has to answer one question: what happens at 100%? rysh answers it at 90 — with instructions you wrote before you walked away.
  Jul 19, 2026 · 6 min read
• Loop engineering: do/while for AI agents
  Unattended agent loops need hard ceilings, a graceful landing, and a written definition of done. rysh makes the loop a reviewable file.
  Jul 19, 2026 · 7 min read
• Your agents live in git: skill files are source code
  Where does your best prompt live right now — a Notion page? A dashboard textarea? Agents should be code: diffed, reviewed, blamed, reverted.
  Jul 19, 2026 · 5 min read
• `##agent spawn-all`: hire a whole team from a folder of markdown
  One folder of .md files, one command, a full roster of specialist agents. Onboarding a team is now a git clone.
  Jul 19, 2026 · 4 min read
• `@agent`: name-addressable coworkers in your terminal
  You @-mention people in Slack. Why can't you @-mention your agents in the terminal? In rysh, you can — @name talks, @@name manages.
  Jul 19, 2026 · 5 min read
• Autonomous agents from a markdown file
  In rysh, a coworker is a markdown file: YAML frontmatter on top, a system prompt below. ##agent spawn does the rest.
  Jul 19, 2026 · 5 min read
• Loop detection: stopping an agent from calling the same tool forever
  Agents don't get bored, and that's the bug: a stuck agent will retry the same failing call forever. Rysh's circuit breaker: 3 identical calls, blocked.
  Jul 19, 2026 · 5 min read
• `##cron`: agents on a schedule
  An agent that only works while you watch isn't autonomous — it's supervised. ##cron gives rysh agents a calendar: nightly triage, morning briefs.
  Jul 19, 2026 · 5 min read
• `##pipe` and `##hop`: composing panes the way Unix composes processes
  Unix's best idea was |. Rysh applies it one level up: panes — shells, agents, chats — composed into workflows instead of processes.
  Jul 19, 2026 · 5 min read
• 46+ built-in agent tools, part 2: cross-pane coordination and shared memory
  Any CLI can give one agent a file tool. Rysh's interesting tools let agents inspect each other, message each other, and share memory.
  Jul 19, 2026 · 4 min read
• 46+ built-in agent tools, part 1: files, search, git, and the web
  More tools don't make a better agent. Rysh's rule: a tool earns a slot only when it beats bash. Here's the working half of the toolbox.
  Jul 19, 2026 · 5 min read
• The bash allowlist: safe-by-default shell execution for agents
  Approve everything and you'll rubber-stamp. Approve nothing and the agent is useless. Rysh's answer: an allowlist where unknown means ask.
  Jul 19, 2026 · 5 min read
• Preview-first editing: coloured diffs before anything touches disk
  Rysh agents don't edit your files and tell you afterwards. You see the diff — green, red, cyan — and the write waits for you.
  Jul 19, 2026 · 5 min read
• Background shells with ring buffers: fire long jobs, check in later
  Agents shouldn't sit and watch a build scroll by. Rysh gives them background shell sessions with 256KB ring buffers — start, work, check back.
  Jul 19, 2026 · 5 min read
• Persistent by default: how JetStream KV remembers your workspace
  Close the laptop. Kill the terminal. Come back tomorrow — your tabs, panes, agent output, and history are still there. Here's the machinery.
  Jul 19, 2026 · 5 min read
• Voice input in the terminal: talk to your panes
  The terminal finally accepts sentences. Rysh lets you speak a prompt into a pane — because agents take natural language, not just syntax.
  Jul 19, 2026 · 5 min read
• The `##` command language: a tiny shell for driving your whole workspace
  Menus don't compose and agents can't click them. Every rysh capability — panes, sessions, sharing, agents — is a typed ## command on the input line.
  Jul 19, 2026 · 5 min read
• Pipeline events: building a software assembly line out of panes
  Lines starting with ##> bypass the PTY and become clean events other panes react to — panes triggering panes, and agents triggering agents.
  Jul 19, 2026 · 6 min read
• `##pane listen`: when one pane watches another work
  One command subscribes a pane to another pane's output streams. It's tail -f for conversations — and the primitive agent teamwork is built on.
  Jul 19, 2026 · 5 min read
• Shell, AI, chat, system: why rysh keeps four output streams per pane
  One scrollback for everything means shell noise buries AI answers. rysh publishes each pane's output on per-mode NATS topics — and merges on purpose.
  Jul 19, 2026 · 5 min read
• Yes, you can run vim inside an agentic multiplexer: raw mode and the VT emulator
  The credibility test for any AI terminal: open vim. Then htop. Then less. How rysh passes with a vt10x emulator, alt-screen detection, and raw mode.
  Jul 19, 2026 · 5 min read
• `rysh send`: drive your agents from any shell, no TUI attached
  One command turns a rysh session into scriptable infrastructure: send shell commands or prompts to any pane from cron, CI, SSH — no screen required.
  Jul 19, 2026 · 5 min read
• Sessions that survive: attach, detach, and never lose an agent mid-task
  Close the laptop mid-refactor. Reattach tomorrow: same tabs, same panes, same agent conversations. How rysh sessions persist everything that matters.
  Jul 19, 2026 · 5 min read
• Stacked panes: why your agents should behave like a deck of cards
  Eight agents don't need eight visible panes. rysh stacks panes like cards — top one visible, the rest as live title bars — and Ctrl+S rotates the deck.
  Jul 19, 2026 · 5 min read
• Tabs, lanes, and stacked panes: a layout system built for humans *and* agents
  tmux layouts were designed for shells. rysh's tab → lane → group → stack hierarchy is designed for a screen full of long-running agent conversations.
  Jul 19, 2026 · 5 min read
• Double-Escape: one keystroke between your shell and your AI
  Every rysh pane has two input modes — shell and prompt. Esc Esc flips between them. That tiny toggle removes the copy-paste bridge you've become.
  Jul 19, 2026 · 5 min read
• Rysh vs building it yourself: the boring 80% you'd rather not maintain
  You're three sprints away from your own agent platform. You've been three sprints away for six months. Let's talk about why.
  Jul 19, 2026 · 5 min read
• letchat.ai vs Intercom Fin: $0.99 per resolution, or a bot you own
  Per-resolution pricing meets a chatbot whose logic lives in your git repo. Do the math on your ticket volume, then decide.
  Jul 19, 2026 · 5 min read
• Rysh vs Claude Tag: whose infra, whose governance, whose keys
  Anthropic put Claude in your Slack. We love Claude — rysh runs on it. The real questions: where does the agent live, and who gates what it says?
  Jul 19, 2026 · 5 min read
• Rysh vs Cursor, Windsurf, and Copilot: editor-bound assistants vs workspace-level agents
  Keep your AI editor. Seriously. This is about the layer above it — where agents stop being autocomplete and start being coworkers.
  Jul 19, 2026 · 5 min read
• Rysh vs LangChain and CrewAI: frameworks are Lego — you still operate the tower
  You can absolutely build your agent platform with a framework. The question is whether you want to operate it forever.
  Jul 19, 2026 · 5 min read
• Rysh vs Herdr and cmux: orchestrating other people's CLIs vs being the engine
  Agent multiplexers are having a moment. But arranging other people's agents in panes and being the agent engine are different products.
  Jul 19, 2026 · 5 min read
• Rysh vs tmux and Zellij: twenty years of panes meet the agent era
  A love letter to the multiplexers I grew up in — and the exact spot where rysh forked the road: a pane is a conversation, not a shell.
  Jul 19, 2026 · 5 min read
• Rysh vs Warp: a smarter terminal, or an AI-native company?
  Warp might be the best terminal ever built. That's exactly why this comparison is about a different question.
  Jul 19, 2026 · 5 min read
• Rysh vs OpenClaw: one binary and a markdown file vs the gateway, the daemon, and the pairing codes
  OpenClaw earned its 383k stars. This is about what a self-hosted assistant costs to operate — counted from the docs, not vibes.
  Jul 19, 2026 · 5 min read
• Rysh vs Codex CLI: a coding agent in your repo vs an agent platform in your company
  Codex-class agents nail the repo loop. The question nobody asks: what happens to agent work that isn't a pull request?
  Jul 19, 2026 · 5 min read
• Better together: running Claude Code *inside* a rysh pane
  Keep your coding agent. Wrap it in a workspace: live sharing, session persistence, headless control, and agents that watch its output.
  Jul 19, 2026 · 5 min read
• Rysh vs Claude Code: many agents behind one input box vs many agents in coordinated panes
  Claude Code already runs many agents. The ceiling isn't capability — it's coordination. Here's the workspace I built on top of it.
  Jul 19, 2026 · 6 min read
• Your company doesn't need another AI subscription. It needs an agent platform
  Count your AI subscriptions. Now count how many share context, logs, or logic. That gap is the argument for a platform — here it is, made concretely.
  Jul 19, 2026 · 5 min read
• Rysh runs on Claude — why we build on the best model instead of pretending we trained one
  We get asked \"so what's your model?\" a lot. Answer: Claude, on your API key. Here's why that's a feature, and where the real work is.
  Jul 19, 2026 · 5 min read
• \"So it's tmux with AI?\" — a five-minute tour that says otherwise
  The fastest way to answer the most common question about rysh: a five-minute tour, one minute per capability tmux structurally can't have.
  Jul 19, 2026 · 5 min read
• The terminal is the most underrated AI surface (and it's where rysh starts)
  Everyone is building chat UIs for AI. Meanwhile the surface where agents are actually strongest has been sitting in your dock for 40 years.
  Jul 19, 2026 · 5 min read
• One binary, no daemon zoo: from `brew install` to a working agent in five minutes
  Self-hosting an AI agent usually costs a weekend of gateway daemons and pairing codes. We timed the rysh version on camera: 1:47.
  Jul 19, 2026 · 6 min read
• Every pane is a conversation: rethinking the terminal for the agent era
  tmux treats a pane as glass in front of a shell. What happens if you treat every pane as a conversation instead? Everything changes.
  Jul 19, 2026 · 5 min read
• AI-painted vs AI-native: most companies bolted a chatbot onto the website and called it done
  There's a test for whether your company is actually AI-native or just AI-painted. Most fail it. Here's the test — and what passing looks like.
  Jul 19, 2026 · 5 min read
• Meet rysh.ai: one agent engine for your terminal, browser, Slack, and website
  Your company probably runs five AIs that don't know each other exist. rysh is one agent engine for every surface — observable and owned.
  Jul 19, 2026 · 6 min read
• Pages, books, and shelves: budget your agents like a library
  1 page = 1,000 tokens. 1 book = 200 pages. 1 shelf = 20 books. Legible budgets get set, argued about, and tuned. Illegible ones rot.
  Jul 16, 2026 · 7 min read
• The two scariest parts of autonomous agents — runaway loops and exposed APIs
  How rysh bounds agent loops with token budgets and graceful takeover, and lets agents call private APIs through a tunnel — never exposing them to the internet.
  Jul 12, 2026 · 9 min read
• Pair-program in the terminal: sharing a live pane
  Rysh has real-time collaboration built in — share a pane, group, lane or whole tab, choose view-only or control, and your teammate can watch or drive from the web or their phone.
  Jun 25, 2026 · 4 min read
• Keeping AI agents safe: how the approval flow works
  An AI that can run shell commands is powerful and risky. Rysh keeps a human in the loop on every sensitive action, detects runaway loops, and redacts secrets from shared output.
  Jun 18, 2026 · 5 min read
• Why every terminal pane should be an AI agent
  AI coding tools live in a browser tab, disconnected from the shell where the work happens. Rysh flips that: every pane is both a real PTY shell and an autonomous AI agent that shares your terminal's context.
  Jun 10, 2026 · 4 min read