The Market Inside Your Company
Private agent chats re-create the open market inside the firm: every person plus agent becomes an isolated contractor whose work nobody else can inspect. The fix is shared state that a team and its agents can see, change, and approve together.
Thanks for listening
Side BTable of Contents · 10 chaptersShowHide
On a Monday morning, one person on a revenue team spends twenty minutes teaching their agent how inbound leads should be routed: who gets the hot ones, what counts as a duplicate, when to ping Slack. It works, they ship the automation, and they move on.
That afternoon, a teammate opens their own chat window and asks their agent to tighten the escalation rule. That second agent has never seen the morning conversation. It does something reasonable, and different.
By Thursday there are two versions of "the" lead-routing automation. When a deal gets misrouted, nobody on the team can say which rules are actually running without asking three people and digging through private chat histories. Nobody did anything wrong. Each person did their job faster than ever, inside a window no one else could see.
I'm a founding product engineer at Glow (#4), an automation platform, so read this as a practitioner's argument, not a neutral survey. I wrote it from my own experience building automations, with AI helping me challenge and edit the draft, and I speak only for myself.
Two old problems
The scene above is an old problem in new clothes. In 1937 a 26-year-old economist, Ronald Coase, asked why companies exist at all. If markets are so efficient, why doesn't everyone work as an independent contractor and trade with everyone else?
His answer was that using the market costs something. You have to discover what the prices are, and negotiate and conclude a separate contract for every exchange. Coase called these "marketing costs"; the label "transaction costs" came later. The three-part list now in common use (search, bargaining, and policing and enforcement) comes from later writers, such as Carl Dahlman in 1979. A firm makes sense when directing people under one roof is cheaper than renegotiating every handoff.
Private agent chats re-create the open market inside the firm: every person plus agent becomes an isolated contractor whose work nobody else can inspect. The context lives in their threads, and so do the rules. The bill comes back in the same three lines: finding out what the other person's agent was told, agreeing who changes what, and checking that what runs is what was meant.
That third line is close to a problem Armen Alchian and Harold Demsetz took up in 1972. They asked what a firm does once people are inside it. When people produce something together and you can only see the joint result, you cannot easily tell who contributed what. The gain is shared and the effort is private, so someone has to watch and measure. They called it the metering problem, and they saw much of what a firm does as an answer to it.
The analogy isn't one-to-one: Alchian and Demsetz were writing about measuring human effort, whereas in software and operations nobody needs to police who worked harder. Still, agents bring a version of the metering problem back, and nobody has to be shirking for it to bite. A team's output is now made by people and agents together, and the record that would let you attribute it (what was asked, what was assumed, what the agent changed) sits in a private thread. The team sees the result, not the change that caused it. If a lead is misrouted on Thursday, nobody can say whose instruction caused it.
The strongest objection runs the other way: agents make outside transactions so cheap that firms can get much smaller, a "Coasean singularity" (the term also titles a 2025 NBER paper on agents and market design).
Maybe, at the edges of the firm. Work that can be specified, priced, and checked from outside will move out. The work that stays in stays because it cannot be specified in advance. It runs on shared context, and private agent threads split exactly that. A Berkeley CMR essay by Thierry Warin warns about the same fragmentation.
Cheaper transactions outside do not make coordination inside cheaper.
What I'm not claiming
Chat is not the problem. I use it all day inside Zed, pairing Claude for code and Gemini models for research. It also works for software teams writing code, for a specific reason: the pull request. A diff is a shared artifact that everyone can read, comment on, and approve before anything merges. Chat plus Git is a complete loop.
Others have made the broader interface argument better than I could. Amelia Wattenberger's "Why Chatbots Are Not the Future" is the piece I point to first. On the GitHub Blog, Ayan Gupta showed how chat works for intent while agent work gets lost in the scroll, and why canvases make agentic workflows visible and steerable. "Chat for intent, a canvas for state" is not my invention.
My point is specifically about teams running cross-app automations across a CRM, Gmail, Slack, and internal data stores, where no pull request exists. You can export an automation as JSON into Git, but that only shows the static definition, not live credentials or runtime traces, and half the people who own a revenue process do not want to review a JSON diff. What is missing is shared state that both engineers and operators can inspect and change together.
Seeing the same thing
If private threads bring back three costs, a team needs three things back: to see the same thing, to change it together, and to trust what runs. Seeing comes first, and it is where chat is weakest.
Chat is a good way to say what you want and a poor way to see what exists. Think of air traffic control. Pilots speak to the tower, but controllers run the airport from a shared radar screen, not by rereading a transcript. Voice carries the intent. The screen carries the state.
An automation has the same split. Four stages (an email arrives, the CRM is checked for a duplicate, an AI step scores the lead, hot deals go to Gmail and Slack) are easy to take in as a map and tedious as a scroll of tool-call logs. On a shared canvas you can point at stage three, circle it, and say "change this condition." The raw material goes on the canvas too: a call transcript as a card, a few sticky notes, a rough sketch. Everyone sees what the agent is working from.
The connected agent appears in the presence bar and on the step card it is editing, paired with the name and avatar of the teammate running it. You still talk to it in chat or by voice. The difference is that everyone else watches the result take shape on the canvas instead of hearing about it on Thursday.
Only Alex sees the rule
Alex teaches their own chat how to route big leads. It works, so they move on.
"Send any lead over $50k to #sales."
Rule lives only in Alex's window
Everyone sees the same rule
Alex's agent builds the 4 steps on the team canvas. Anyone can click Step 3 and read the $50k rule.
✓ Chat for intent · Canvas for state
A bot in a group chat is a different thing. Putting an agent in a Slack channel gives everyone the same log, not the same object. PostHog, which has been building multiplayer AI, describes chat tools like its Slack bot as a UI bottleneck that forces people to translate rich information into flat text, and notes that in 90 days only 64 users started a separate shared context file in its product, and only 14 ever edited one.
That is also my answer to the obvious alternative, a shared rules file that every agent reads. A file like that is one more document about the work, and documents about work go stale. Shared context only stays accurate when it is the actual object people and agents work on. When the automation itself is the shared context, there is no second document to forget.
Changing it together
Seeing the same thing isn't enough if one person's agent silently overwrites another person's work. The second cost is coordination: agreeing who changes what without stepping on each other.
Some automation tools save the whole automation as one document, so if an agent adds a step while you edit a prompt in another, one save overwrites the other. The fix is to make the step, not the document, the unit of change.
In Glow, edits to different steps merge live, and an agent working over MCP, the open protocol that lets an AI agent use outside tools, cannot overwrite a step a teammate has changed since the agent last read it. The engine rejects the write until the agent re-reads the current state.
The metering problem gets its answer here. Version history and the structural diff record whether a person or an agent made each change, and why. If a lead is misrouted on Thursday, the team opens the history and sees which edit changed the rule, instead of polling the room.
Trusting what runs
The third cost is enforcement: making sure what runs is what the team meant to run. In a market you settle that with contracts. In a team you want rules the engine enforces automatically, plus a review gate before changes go live.
Those rules live in the engine, not in the browser, so they apply to every agent, whichever tool it connects from. The canvas makes them visible to everyone. Three matter most:
- 01
Schema validation
If the agent invents a spreadsheet column that doesn't exist, the engine rejects it and returns the real columns.
- 02
Secret protection
An automation legitimately needs to send API keys in request headers. The engine blocks the places where a secret would be exposed or echoed back, such as AI prompts, file exports, and webhook replies.
- 03
Preview mode
Reads, filters, and AI steps run for real, but every external write and every generic HTTP request (even a GET, which could trigger an external webhook) stops at the door and records a receipt of what it would have sent.
Then there is the release boundary. Edits and tests happen in a draft. Whenever an agent edits a live automation (or when a team locks an automation to manual releases), Live keeps serving production traffic until a person inspects the structural diff and clicks Release. That diff, paired with the preview receipts, is the closest thing a cross-app automation has to a pull request. And if a production run fails weeks later, the agent can read the failed step's trace, fix the draft, and replay the exact event before anything goes live.
None of this knows your business intent. Schema validation can tell you a field exists; it cannot tell you that a valid email address belongs to the right client. Preview mode reads real data and spends real AI tokens, so it is not a free simulation. That is why a human still reads the receipt.
Two real moments from building this
The first moment is what happens when two of us work on the same automation at once. While I'm in Zed asking Claude to wire up the downstream Slack and CRM steps over MCP, a teammate has step three open on the canvas tweaking the email copy. When Claude tries to touch step three using stale context from two minutes ago, the engine refuses the write and forces the agent to re-read the canvas first. Nobody's edit gets silently wiped out.
The second moment is from Episode 04 of my unscripted build videos, where I connect Claude to both Glow MCP and Gmail MCP. Claude builds a lead-triage automation from a sales-call transcript, then uses Gmail MCP to send seven realistic test emails (hot, warm, and cold) into a test inbox. Every step on the canvas lights up green.
Green means the pipeline connected and ran without runtime errors. It does not mean the lead scoring or the drafted reply is good, so I still read the Slack brief and the email draft myself. The difference is where the results live. I click the step on the canvas and read them in place, and so can anyone else on the team, without me forwarding my chat with Claude.
Where this doesn't help
For one person doing a one-off job, a shared canvas is overhead. Chat is faster, and for complex solo work it is hard to beat. A canvas starts to pay off when an automation outlives a single prompt and becomes something a team has to trust, debug, and maintain together.
It doesn't fix bad business logic, and it doesn't replace judgment. Multiplayer brings its own headaches: conflicts, permissions, and deciding who is allowed to touch production. And I build this for a living, so weigh my enthusiasm accordingly.
Back to the firm
The point of a firm isn't that everyone does the same thing. It's that the work lives somewhere everyone can see, change, and answer for. Agents didn't change that. They raised the stakes, because the work now moves faster than anyone can explain it in a standup.
Chat is still the best way I know to say what you want. A team also needs a place where what you wanted becomes something the rest of the team can check before it runs. Without that, you've rebuilt the market inside your company, one private thread at a time.
Related reading and sources
- Amelia Wattenberger, Why Chatbots Are Not the Future
- Ayan Gupta, How canvases make agentic workflows visible, steerable, and cost-efficient, GitHub Blog, Aug 17, 2026
- Jina Yoon, We're building multiplayer AI. Here's what we've learned so far, PostHog, Sep 28, 2026
- Ronald Coase, "The Nature of the Firm," Economica, 1937 (JSTOR; and his 1991 Nobel Prize lecture on transaction costs)
- Armen Alchian and Harold Demsetz, "Production, Information Costs, and Economic Organization," American Economic Review, 1972 (JSTOR; the metering problem)
- Carl J. Dahlman, The Problem of Externality, Journal of Law and Economics, 1979 (JSTOR; the search, bargaining, and policing split of transaction costs)
- Howard Yu, Coase vs. Claude and the Future of the Firm, IMD
- Thierry Warin, From Coase to AI Agents: Why the Economics of the Firm Still Matters in the Age of Automation, California Management Review, 2025
- Peyman Shahidi, Gili Rusak, Benjamin Manning, Andrey Fradkin, and John Horton, The Coasean Singularity? Demand, Supply, and Market Design with AI Agents, NBER Working Paper 34468, 2025
- Watch it live: sebbuild.com and YouTube @sebbuild (Episode 04 and Episode 05 walkthroughs)
Disagree, or seen this play out differently on your team? Write to me →