Skip to main content
 · Updated  · 9 min read · 13:43 audio

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.

By Sebastian Hozak

The Market Inside Your Company

13:43

AI voice · ElevenLabs

Table of Contents · 10 chapters
Show
  1. Monday morning
  2. Two old problems
  3. What I'm not claiming
  4. Seeing the same thing
  5. Changing it together
  6. Trusting what runs
  7. Two real moments from building this
  8. Where this doesn't help
  9. Back to the firm
  10. Related reading and sources

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.

Private chats

Only Alex sees the rule

Alex teaches their own chat how to route big leads. It works, so they move on.

Alex's private chat

"Send any lead over $50k to #sales."

Rule lives only in Alex's window

Shared canvasLive

Everyone sees the same rule

01
Email
02
CRM check
03
Over $50k?
04
#sales
Visible to the whole team

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

Figure 1. One lead-routing rule from Monday to Thursday, in private chats and on a shared canvas. Step through the three moments.

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:

  1. 01

    Schema validation

    If the agent invents a spreadsheet column that doesn't exist, the engine rejects it and returns the real columns.

  2. 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.

  3. 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

Disagree, or seen this play out differently on your team? Write to me →

Or select any sentence above to share just that line.

Get the next essay

One email when the next one is ready. Nothing else.

Sebastian Hozak
Author

Sebastian Hozak

Founding Product Engineer @ Glow (#4)

About →