My favorite detail in this one: after kicking off the install, the agent doesn't sit there polling. It arms a one-shot trigger, ends its turn, and gets woken when the install is ready. No sleep loops, no tokens spent polling.
Agentic development has three real limits right now: agents lose context, inference gets expensive, and you can't see what went wrong.
All three are fixable. They're mostly infrastructure problems, not model problems.
Here's how we handle each in iii:
Context: there's a live registry of everything the system can do. The agent doesn't guess or rely on stale docs. It looks at what exists right now.
Cost: the context agents get is richer and more accurate, so they make fewer wrong calls, and avoid context pollution. Less wasted inference.
Visibility: everything is traced end to end out of the box, no matter what you build with it. When something fails, the agent already has everything it needs to fix it.
The limits aren't permanent. They just need the right infrastructure.
Bonus: Here's 38 things I learned while solving for this.
We shipped function observers in iii 0.25. What they do is incredible and it's something I've never seen done like this before.
Here's an example: Your team needs to know about purchases that were over $500. You don't control the service that handles purchases. The team that does is backlogged. In any other stack you'd need to escalate, negotiate, and plead with the team to move this requirement up. Then you'd need that other team to implement, test, deploy, and monitor. Finally you can do your work.
With observables you just filter input_total >= 500 over the purchase order function and it just works. Same on outputs, same on errors. Nothing else needs to change.
This means the flexibility to respond to business needs and grow your products rapidly without the headache of constant redeploying, or needing to know Day 100's requirements on Day 1.
Ohh and we made iii significantly faster while doing this too.
Every month it's the same thing: massive inference bills. So we started running tests. Same task, same model (Sonnet 5, low thinking): 63 cents in Claude Code, 48 cents in our harness. Then we swapped in DeepSeek Flash and it was 10 cents. iii.dev/blog/coding-agent-co…
I really don't want to compete on cloud agents. Hundreds of companies plus the big labs are already there. Very few people are building backends where traditional and agentic systems run as one thing. That's what we're doing at iii.
Proud to announce that @mozilla is the first outside contributor to our worker registry!
Think about how many kanban boards you’ve used this year. Linear has one. Jira has one. Trello is one. GitHub Projects has one. Every coding agent now ships one to show you what it’s working on.
Every one of them was built from scratch. Columns, cards, drag and drop, status, assignees, comments, written again and again by a different team every time. It’s one of the most re-implemented pieces of software there is and there are tons of others.
Anthony on our team needed one last week. He was building a pull request review tool with an agent in our ADE, and he wanted questions about specific lines of a diff to turn into tickets that agents pick up and work on.
He got a board but didn't need to build it. The agent found the kanban board Sergio built and the rest of the team has been extending, added it to the project, and it was ready immediately for this new review tool to use.
The whole tool went from the first prompt to running in under five minutes, and Anthony kept expanding his PR review tool over the next hour. The board’s code never needed to change.
Build it once, compose it everywhere.
We just shipped tmux in the ADE. Most people running agents seriously already live in tmux, so instead of asking them to switch, we brought iii to them. Same keys, same config, and now you can see which agent is waiting on you.
Deploying your app? Here are 31 things I've learned that every app needs when they get to production. If you have your own leave a comment.
In our new agentic world these will be the minimum requirements for all software.
Favorite bug report this month came from the agent itself. It kept telling Sergio the memories we were feeding it had nothing to do with his task. Same ones every turn. Fixed now.
This is the importance of identifying and solving for the right problem.
The custom harnesses our users are building do something no other harness can: be proactive.
Agents stay informed of system-wide changes because we built iii focused on the system where our software is deployed, rather than the harness where it's built or run.
Explaining iii is hard because it only lands once you've felt what a big system looks like at the other end, when you try to grow that system, bring it to production, and expand your customer base.
@MikkelFishman at Bonnie Builds broke it down simply: Structured systems are computable but hard to flex inside, so everything swung to unstructured.
Now it's "throw it all at the LLM every turn and let it figure itself out".
What they do instead is capture it unstructured, structure it through the LLMs, and run it as workflows with iii that stay dynamic. You need infrastructure that can execute that while preventing the ossification that typically happens to workflows.
While developing iii we've noticed that time and time again agents will continually encounter the same problems, with the same solutions. This happens in every harness we've used across the team.
This is a huge problem because it makes work slower, more expensive, and less correct as agents pollute their context with error messages.
We're solving this with a new tool we call "sentinel". It's a secondary AI that watches our primary agents and the execution context of the system. It reads traces directly from iii, not logs, not agent summaries. Then it records what happened, why, and how to fix it.
We can then take these logs and use them to improve iii, our workflows, and get actionable data on repeat problems. In the future we think that our end users will be able to take advantage of this for their own development velocity and for getting us better bug reports.
It will be out soon. Comment "sentinel" below if you want me to ping you when it's ready.
I find it incredibly hard to optimize my agents and harnesses because I can't see exactly what tokens were spent on. Was it spent on actual work getting done, or just the agent spinning its wheels?
We could solve this easily with iii. Would it be useful to you? If I'm not alone comment below.
CLIs are a stop gap for agents. How many times have you watched your agent grep `gh --help` or re-read a file it just wrote?
The problem is that CLIs seem like a great idea but every new session needs to rediscover how to use a given CLI, and then how to observe what the command did.
It's this constant loop of discover functionality, execute, and discover how to observe that execution. Worse yet each and every tool varies in its discovery and execution steps.
This is one of many reasons that I think iii makes a better system for agents: it is a system. All discovery, all execution has the same interface.
Lately we've been enhancing existing tools for iii by wrapping them in our interface, we've done this with github, browser control, worktree, jev, laya, semif, email, claude-code, pi, codex, opencode, telegram, mcp, pdf reading, slack, computer use, document conversion, and so much more.
Every single tool looks and behaves the exact same way, rather than the alternative of disjointed CLIs.
This is exactly what I hoped would start happening with iii.
See an orchestration pattern → compose it yourself from the primitives → make it your own.
We shouldn’t need a new framework every time someone invents a new agent pattern.
The runtime should be general enough that the pattern is just an application.
nitter.cf/lgswitter/status/21032…
The level of parallelism and coordination you can reach with @iiidevs Harness is honestly unlike anything I've used before.
In this run, a single parent agent spawned 13 specialized sub-agents.
Each agent had: • one domain • one objective • one responsibility
🧵👇
