# AI Agents Are Managing AI Agents. The Real Question Is Who Enforces the Rules.

> Source: <https://pub.towardsai.net/ai-agents-are-managing-ai-agents-the-real-question-is-who-enforces-the-rules-bb6fc06b15f7?source=rss----98111c9905da---4>
> Published: 2026-11-20 15:31:01+00:00

**Recommendation:** Encode standards as intent.yaml and component.yaml files that compile to a deterministic plan, and make rule violations exit non-zero so the coding agent sees the exact failure it cannot argue past.
More in the playbook "Designing agent systems": <https://wpnews.pro/playbooks/agent-architecture>

On November 17, Cognition launched [Devin Bots](https://devin.ai/blog/introducing-devin-bots), persistent agents that own outcomes and lead teams of Devins. One of their examples is their colleague Jenny Xu, who runs a mobile game studio. She’s the only human left. She has about 20 bots doing the actual work (dev, Unity, releases, QA, the lot). Above them sits a Super Jenny Bot, the only one she talks to, four times a day it gathers the decisions the others need into one Slack thread, and she answers with emoji. The studio went from about 50 pull requests a week to roughly 1,900 and now ships a release every week.

Sit with that for a second. Nobody is reading 1,900 pull requests a week.

This is the natural next step after OpenAI’s Dots and Anthropic’s Duet. Agents that used to wait for tasks now have managers that are also agents. The author is an agent, the manager is an agent, and the humans are outnumbered. Supply of code is no longer the constraint. The constraint is whether anything still holds the output to a standard when the people who used to do that job are no longer in the loop.

I wanted to feel what that looks like at a small, honest scale, so I gave a blog a real set of rules for a coding agent to write into. The tool I used is [orun](https://github.com/sourceplane/orun). It’s an open-source Go binary whose whole idea is “platform discipline as code.” You write the standards as files in the repo. orun turns them into a deterministic plan and refuses to run anything that doesn’t match.

You declare three things.

Platform intent (intent.yaml) says which environments exist and the order things promote. Component intent (component.yaml) sits next to each unit of work and says what it is. A composition is the golden path for a type of component, its schema, its steps, and which profiles run which steps.

orun validates all of it, compiles it into a plan you can look at before anything runs, and then executes the plan. Identical inputs always produce the same plan. Your coding agent works inside the same files and the same command. If it breaks a rule, the command exits non-zero and the agent sees the exact failure. It cannot talk its way past a schema or a promotion order.

I kept the example small on purpose. A blog has real editorial rules and an agent can write most of it.

The repository is ordinary.

```
signal-blog/├── intent.yaml├── CLAUDE.md├── stack/                       # the golden path│   └── compositions/static-blog/└── sites/blog/    ├── component.yaml    ├── check.js    ├── build.js    └── posts/*.md
```

intent.yaml is short. Staging and production. Production cannot run until staging has succeeded.

```
environments:  staging: {}  production:    promotion:      dependsOn:        - environment: staging
```

The composition defines one job with three steps for anything of type static-blog: check, build, publish. Two profiles pick which steps run. Preview does check and build. Publish does all three. The schema requires a title and a base URL that matches ^https://. A blog that is not HTTPS never even plans.

The editorial rules live in check.js, a few lines of plain Node. Every post needs title, date, and summary in front matter, and it must cite at least one https:// source. build.js turns the Markdown into HTML. You can swap in Astro or Hugo if you want. orun does not care what the steps run.

You can see the promotion order and the exact steps before a single command runs. That plan is what you review. The run is just the plan executing.

I put a short brief in CLAUDE.md at the root,

Then the prompt is one line “Write a post about Cognition’s Devin Bots launch and what it means for code review.”

Say the first draft skips the summary and the source, the exact things a fast author skips:

```
---title: The managers are bots nowdate: 2026-11-18---Cognition shipped a supervisor for its coding agents.
```

The brief says to run the plan, and this is what the run says:

Two useful things happen. The error names the file and the exact rule, so an agent can fix it without me. And production never starts, because the promotion order is declared, not hoped for. Add the summary and a source, rerun, and both jobs go green.

The same thing happens with structure. If the agent “simplifies” the base URL to http://, there is no run to fail. There is no plan:

```
✕ component validation failed: component blog failed validation against  type static-blog: '/inputs/baseUrl' does not match pattern '^https://'
```

None of this depends on the agent being careful or on me reading the diff. That is the point.

A one-person blog is the toy version. The same pieces scale. A stack can be published as a versioned OCI artifact so ten repositories pin the same golden path and upgrade it like a library. orun mcp serve exposes the catalog, runs, and logs to an agent over MCP. orun skills pull installs hosted skills for Claude Code, Codex, Cursor, or VS Code. orun baseline new scaffolds a full production-shaped repository from a baseline, and the software-factory skill drives that end to end from a one-paragraph brief, with each change landing as its own pull request.

The Devin Bots launch is a story about volume. Far more code, from far more authors, than people can read. Volume was never the hard part. The hard part is the standard the code is held to once the manager is also an agent. A standard that lives in a wiki or in a reviewer’s head does not survive 1,900 pull requests a week.

Write the standard down where a machine reads it. Then let the agents run.

orun is open source (MIT) at [github.com/sourceplane/orun](https://github.com/sourceplane/orun), with docs at [orun.dev/docs](https://orun.dev/docs/).

*Disclosure: I work with Orunbase, a company building an agentic developer platform and also behind the orun cli. I’m sharing my own perspective on how engineering organizations need to rethink context, governance, and trust as AI agents become part of the software development process.*

Connect with me on LinkedIn: [linkedin.com/in/atomicflee/](https://www.linkedin.com/in/atomicflee/)

Learn more about Orunbase: [orunbase.com](https://orunbase.com).

[AI Agents Are Managing AI Agents. The Real Question Is Who Enforces the Rules.](https://pub.towardsai.net/ai-agents-are-managing-ai-agents-the-real-question-is-who-enforces-the-rules-bb6fc06b15f7) was originally published in [Towards AI](https://pub.towardsai.net) on Medium, where people are continuing the conversation by highlighting and responding to this story.
