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.
Let me be upfront about what this is and isn't.
This is not a case study. There's no anonymized "Company X" that did all of this last quarter — we're an early-stage platform and we don't invent customers. What follows is an illustrative composite: a walkthrough of what a working week looks like when a small company runs dev, ops, and support workflows on rysh. Every capability named below is shipped and works the way described; the week itself is a construction to show how the pieces fit.
The point of the exercise: "AI-native" is abstract until you can picture Tuesday. So here's the week — a ~20-person product company, a few engineers, one ops-minded person, one support lead.
Monday: the team you hire from a git repo
The engineering lead opens a terminal and runs one command:
##agent spawn-all ./agents/
That folder is in the company repo. Each .md file in it is an agent — a name, a system prompt, the behavior — versioned like any other source code. This morning it holds a code-reviewer, a test-triager, and a backlog-gardener. Spawning the team is not a procurement process; it's reading a directory.
Each agent lives in a pane, next to the humans' shells, in the same multiplexer. When an engineer wants the reviewer's eyes on a change, it's one line:
@code-reviewer review the diff on this branch
The response streams into the pane. Every tool call the agent makes — every file it reads, every command it runs — is visible right there. New teammates learn what the agents do the same way they learn what the humans do: by watching them work.
The backlog-gardener spends the day on the boring-but-important pile: the small refactors, the dependency bumps, the lint debt. It can read and search freely, but anything that writes — an edit, a commit — surfaces as a preview with a diff, waiting for a human's approval. Autonomy for the safe stuff, a gate on the rest.
Tuesday: ops that watch while you sleep
The ops engineer maintains a set of scheduled agents — ##cron entries that run checks on a cadence: build health, disk usage on the staging boxes, a morning summary of anything that drifted overnight. Each run is a loop with an explicit budget — bounded iterations and spend, in plain numbers the team agreed on — because an unattended agent without a budget is just a bill with initiative.
Mid-afternoon, something in staging misbehaves. The engineer investigating shares their pane with a colleague:
##share pane view
The colleague subscribes from their own terminal and watches the live investigation — the shell, the agent's analysis, all of it — without screen-share ceremony. When it makes sense to hand over the keyboard, the share flips to control mode. Human and agent output sit in the same pane history, so "what happened here?" has one answer, in order, with timestamps.
Secrets in that shared stream? Redacted client-side before the output ever leaves the machine. Sharing your terminal stops being an act of trust in everyone's screen hygiene.
Wednesday: support that drafts before it sends
The support lead runs a humanoid — an agent wired to external channels. Its definition is, again, one markdown file: the personality, the knowledge, the contacts section that connects it to the support inbox, the team's Slack, and the website chat widget.
On email, it runs in draft-and-confirm: the agent reads each incoming message, writes a reply, and the reply lands as a draft the support lead approves in the terminal before anything is sent. The customer gets a fast, well-written answer; the company gets a guarantee that no unreviewed text reaches a customer. On the internal Slack channel, the same agent answers teammates' product questions directly, with the full exchange observable in its pane.
That per-channel governance dial is the whole trust model in miniature: start every channel careful, watch the drafts, grant autonomy where the evidence supports it — and keep the trace either way.
Thursday: the browser is a surface too
Marketing wants a recurring research chore handled: checking a list of directories and communities for mentions and opportunities. An engineer writes it as a browser recipe — a markdown file describing the task — and runs it with ##auto web. An agent drives a real Chrome session: navigating, reading, extracting, compiling a shortlist into the pane.
It's the same engine that ran Monday's code review, on a different surface, with the same rules: bounded budget, observable actions, a human deciding what happens with the output. Discovery is automated; the humans do the outreach.
Meanwhile the CTO, traveling, checks on the week's long-running agents from a laptop with nothing installed but SSH:
rysh send ops-session "status summary" --mode prompt
The session at the office answers. Attach, detach, send from any shell — the agents are processes the company runs, not tabs someone forgot to keep open.
Friday: the review that makes it compound
Friday afternoon, thirty minutes, the whole AI operation in review — and because everything ran in panes, the review is concrete instead of vibes:
- Which approvals fired this week, and were any of them surprises?
- How did the support humanoid's email drafts hold up — is that channel ready for more autonomy, or not yet?
- Did any loop hit its budget or its takeover threshold, and why?
- What edits do the agent files need? Those changes go in as pull requests — reviewed, versioned, in the same repo as everything else.
That last part is easy to underrate. The company's accumulated judgment about how its agents should behave isn't trapped in a vendor dashboard. It's in git, growing, owned.
What the week adds up to
Notice what was absent. No black boxes: every action, human or agent, happened in an observable pane. No leap-of-faith autonomy: writes were gated, customer-facing replies were drafts until earned. No integration sprawl: dev, ops, support, and browser work ran on one engine — rysh, self-hostable, running on Claude with the company's own API key — instead of four disconnected AI subscriptions with four audit stories.
And no transformation program. Just workflows, moved one at a time onto a foundation where the company could see, gate, and own the work.
That's the honest picture of AI-native: not a company run by AI, but a company where agents hold real jobs, in the open, on infrastructure and logic the company controls. The week above is illustrative — but every piece of it is real, and assembling your version of it starts with exactly one workflow.
We're taking on a handful of design partners — companies that want to build their version of this week on real workflows, with us in the loop. If that's you: rysh.ai/design-partner.
Related: What it actually means to be an AI-native company · The governance gap