How to turn the Agent on your laptop into one your whole team can run. Without an engineer, without a rewrite, and without it breaking when you're on vacation
Marketing, Sales, HR, Finance, and IT can build an agent in minutes, prove it works before it runs, and hand it to the team on the organization's accounts. Engineering quality, without the engineers.
9 min read
The fastest way to end up with an engineering project is to tell your business users to build agents.
They will build them, and some will be good. Six months later the good ones are stuck — the agent works, but only when the person who built it runs it, on their machine, with their credentials, carrying their context. Ask anyone else to use it and it breaks. Ask what it would take to fix that, and the answer comes back: put an engineer on it.
Which is what everyone was trying to avoid.
The Personal Agent Trap: there's nothing to hand over
Nobody is hoarding anything.
Ask the person who built it to hand it over and they'll want to. Then they'll discover there's nothing to hand over. The Agent isn't a file — it's a conversation that went well, running against someone's connected accounts, shaped by the corrections they made when it went sideways. Copy the prompt and you only get part of it.
The rest lives in their accounts, their context, and their head.
This is what AI transformation actually looks like on the ground. Not one clean rollout — every department building at once, in parallel, with nobody able to use anyone else's work. Marketing has six agents. Sales has four. Finance has one that only runs on the last Thursday of the month, on one laptop.
None of them can leave the person who built them.
So the same work gets rebuilt by the next person. Or it doesn't get rebuilt at all, and everyone keeps waiting on the one person who knows how to make it work. And when that person leaves, the work leaves with them.
This is not a shortage of ability.
Claude, ChatGPT, Cursor, n8n, Skills, Agent Plugins — building agents keeps getting easier, and we expect the number inside companies to grow tenfold. That's a tailwind, not a threat. What's scarce isn't agents.
It's agents an organization can own.
Owning one means what it has always meant for software a business depends on: you can see what it is supposed to do, hand it to someone else and have it still work, and tell what happened when it ran.
Key #1: chat to Dry Run in minutes, with a Spec anyone can read, repeat and reuse
Chat windows can't be handed to anyone.
So you start in JoyStream the way you'd start with any assistant — describe the work — and what comes out is not a transcript.
JoyStream turns the conversation into a Spec: a plain statement of what the work is supposed to accomplish, which systems it touches, and where its limits are. Short enough that a colleague reads it in a minute and tells you whether you got it right.
The intent stops living in a chat window and becomes an object.
Underneath it sits a Recipe — the plan (think Terraform plan) the Agent implements to do the work. It's the answer to what people actually mean when they ask whether an agent is safe: will it do the same thing next Tuesday?
Then, before anything real is touched, you run it as a Dry Run and see the whole job laid out — every step, every system, in business language rather than tool calls.
All of that takes minutes, not a sprint.
And you can send that Dry Run to someone.
That's the part we care most about. A Dry Run isn't a log you screenshot into a Slack thread — it's a shared object, the way a doc is shared. Your manager opens it and sees what will happen. Your teammate opens it and sees exactly what you saw, because the Spec travelled with it.
Key #2: put the credentials on the organization, not on you
Here is where most shared agents die.
Your colleague opens it, hits run, and nothing happens — because the connection to Salesforce or GitHub belonged to you. So in JoyStream the credentials don't belong to the Agent, and they don't belong to you. The organization connects a system once and grants it where it's needed. The Agent never holds the secret; it holds a reference and borrows the authority to act, scoped to the one thing the work requires.
And the same thing that makes credentials organizational makes everything else organizational.
Who can build, who can run, who can promote something to Live — those become org decisions rather than per-person ones. Every Run leaves a record: what happened, on whose authority, against which systems. Not because someone asked for an audit trail, but because that is what it means for work to belong to a team.
Which means when you hand an Agent to a teammate, it runs.
That is the moment an Agent stops being yours.
Bounded like a workflow. Intelligent like an agent.
Until now there have been two shapes of agent, and neither is what you want.
A workflow is bounded but brittle — rigid steps that shatter the moment reality shifts. A vibe agent is intelligent but unbounded — it improvises, sometimes well, sometimes outside every guardrail you thought you'd set. Most of what's being built inside companies right now is the second kind, and it works in the demo because the person who built it was steering.
The Spec and the Recipe make an Agent both.
It reasons through the messy middle a script can't handle, inside boundaries someone approved. Think of it as a route plan. You approve the journey before the car leaves the driveway.
The driver still picks the best road to each stop.
Dry Run, Pilot, Live: nothing reaches production on confidence alone
The moment an Agent becomes shareable, it also becomes riskier.
An Agent your whole team can run is more useful than one trapped on a laptop. It's also a bigger deal when it's wrong. So every Agent moves through three stages, and you decide when it advances.
Dry Run — nothing real is touched. This is where you look at the work before it exists.
Pilot — real systems, deliberately bounded. This is where you find out what your actual data does to it, which is never quite what the Dry Run predicted.
Live — production. It runs on a schedule or on request, for anyone you've given it to.
If you've shipped software you already know this ladder.
It's staging, canary, rollout, and it exists because nobody sane puts something in front of customers on the first try. We didn't invent a new trust model for agents; we made agents fit the one that already works. And what you inspected is what runs — the Agent version, its Spec, its Recipe, and the exact actions it resolved are frozen together and travel into production as one thing.
Production doesn't rediscover anything.
Every execution then becomes a Run: what it did, which systems it touched, what came back, where a human needed to step in. Not a log file. A record of the work, readable by the person who owns the outcome.
Deployment stops being a leap of faith and becomes a review of evidence.
What this looks like: the agent that posts our daily GitHub summary
Every morning a JoyStream Agent reads yesterday's changes in our own repo and posts a summary to #eng-daily.
Ten pull requests merged, what each one did, in English. It is the most rebuilt agent in software — everyone writes this, everyone writes it slightly differently, and everyone's copy stops working when they're on vacation. Ours has a Spec anyone on the team can read.
- Agent Runs now show on the agent page
- Trial-credit funding path fixed
- Credit pricing moved to a versioned table
It ran as a Dry Run before it ever posted. It went through Pilot. It's Live now, on the organization's GitHub and Slack connections — not on mine. When someone wants it to say something different, they change the Spec, and it goes through the same three stages again.
That's the whole argument, in one small Agent.
Build it here, or bring the Skills you already use
Nothing above depends on the Agent being born in JoyStream.
You can start with repeatable work here and we'll turn it into one. Or bring the Skills and MCP tools your team already uses — Agent Plugins are coming shortly, and we work with the formats the ecosystem is standardizing on. A partner or a consultant can build one for you.
Creation is the abundant part, and we don't need to own it.
What we care about is what happens next — that the thing becomes something the organization can read, share, run, operate, and improve. That the twenty agents on someone's laptop become twenty the team can use. The Agent is one implementation; the capability is the asset — lead qualification, onboarding, month-end close.
Those were never one person's to begin with.
An Agent your organization can own, rather than one person. That's an Organizational Agent. Spec and Dry Run make intent shareable, the Control Plane makes access organizational, Dry Run → Pilot → Live makes production earned, and Runs make it accountable.
That's an operating system. We're building it for Organizational Agents, and this is the first release.
We're onboarding a few teams at a time
JoyStream is live, and we use it to run parts of JoyStream.
The waitlist isn't the product catching up. It's us. We're onboarding a few teams at a time because we want to be in the room while your first Agents get built and shared, and that doesn't scale past a handful at once.
It will open up. Right now it's small on purpose.
If you have work that should already be shared — the digest someone rebuilt four times, the qualification flow one rep figured out, the weekly report that stops when its owner is on vacation — that works today. Get on the list and we'll get you in.
If you're building the OS for your function — and you'll know if you are, because you have a dozen agents already and no way to hand them to the people who need them — talk to us directly. That's the design-partner conversation, and we'd rather have it live than through a form.
That second group is where the next part gets built.
Sharing and scoped access are solved. What comes after is approval: making an Agent something a business owner can review and authorize without reading a single tool call. We're designing that with people who actually have to get that sign-off, which is not us.
What we ask: one real piece of repeatable work, a kickoff session, and honest reactions while we build it with you. Weeks, not quarters.
What you get: direct access to us, design-partner pricing locked for the term, and disproportionate influence over what ships next.
And we'll show our work as we go — regularly: an Agent we built for our own company, including the ones that didn't survive review, and one piece of real work someone turned into an Agent, with the Spec, the Dry Run, and what happened in production.
If there's work your team repeats that should belong to the team, come build it with us.
Join the waitlist → · or talk to the founders
— Harpreet, CEO, JoyStream.ai