E1pi wrote E1pi.

00Eighteen months at a glance

The whole journey, before the detail. Three moments changed the direction: the Agent SDK, Skills, and the three months it took to solve Pipe HTML.

01The brief: check every bill, in every language

The aim of E1pi was never grand. Help a business with its routine tasks. Ours was a battery business running in ten countries in Asia, and the routine task that hurt most was the books: supplier bills in Thai, Vietnamese, Hindi, Bahasa and Chinese, in seven currencies, typed into accounting software by people who would never see the original bill twice. Auditors check a sample. We wanted a hundred percent.

Eighteen months ago that meant GPT-4o. We pasted code in, pasted code out, and were amazed at what it could do. We were also, without noticing, already building a harness — a very slow one, made of clipboard and patience.

02The terminal, then the editor

Claude Code changed the pace. The model could open our files, run our scripts, read the error and fix it. But it lived in a terminal, and a few team members simply would not use one. So we moved the same AI inside VS Code, where the files were visible and the fear was lower.

Both had the same limit. One person at a time, and nobody else could see what had been done. Every teammate needed their own seat, their own setup, their own history. For a team of eight in a battery company, that is not a tool; that is eight tools.

03The first harness: one Mac, one subscription, eight people

When the Claude Agent SDK was released, we did the obvious thing: wired it to an Express web server on one Mac and put a browser page in front of it. Each person signed in as themselves. Each request streamed back to the browser as it ran — the plan, the thinking, the tool calls, the result.

Two things happened at once. The whole team shared one AI subscription, perfectly, with each person’s sessions, tasks and history kept apart. And everyone could see everyone’s runs. A colleague’s request was no longer invisible work on a laptop; it was a line on a shared feed with a link back to the session. That is still the shape of E1pi today: a small server at your place, a page in your browser, and a feed the admin can read from top to bottom.

04Skills, and why we never built on MCP

We have not forgotten MCP. We looked hard for a use case and could not find one. What bothered us most: with a perfectly defined tool schema, every input and every output is fixed in advance. It took the creativity away from the AI. A small change in one value meant rebuilding and redeploying the tool. To this day, not one E1pi business capability is an MCP tool.

Skills were a gift. A Skill is a readable document that tells the AI how to do a job — which data to read, which checks to run, what the output should look like, when to stop and ask. Open it, edit a line, save, and the whole team’s AI follows the new rule a minute later. No schema, no build, no developer.

That first Skill deserves a line. It commits every code change to GitHub with a description of what moved, and it updates our internal SQL server. Later it began announcing each commit in the Microsoft Teams group chat with a link to the E1pi session that made it, so anyone can open that session and ask for the next change with all the context already there. E1pi has been building E1pi ever since.

05It worked too well to sell

By early 2026 everything was, frankly, perfect. We had implemented E1pi heavily across the battery group and it worked beyond expectation. It changed the way we work. And we still could not imagine launching it as a service.

The reason is simple. Skills require a frontier-level model, and frontier models are so expensive that no company would pay for them per token. Even a company with the cash flow would soon learn what we had learnt: more tokens is not more work. More tokens is, mostly, a waste of time and money.

The obvious fix was structured output: have the model return data, feed it into HTML. But the final result still had to reach the browser, and it was still the AI streaming it there — a dollar for every word. Ask for the same report tomorrow and you pay for the same thing again. And even if we took the model out of the data path entirely, the data flow itself was the problem: in a multi-user harness, the AI was directing traffic for every user at once.

“Ask for the same report again, and you are charged for the same thing, times whatever the model feels like today. That was never going to work.”The problem that took three months

06Three months to Pipe HTML

The answer was to stop treating the AI as a courier. In Pipe HTML the model sends a short instruction — which report, which company, which period, which layout. The harness runs the code, reads the books, and the browser draws the result. The data never passes through the model. The same report tomorrow costs nothing, because the model is not involved in drawing it at all.

It took three months, most of them spent on the multi-user part: who is allowed to see what, how a report rendered for one person stays out of another’s session, and how a running request keeps streaming its thinking while the report draws beside it. A separate post will explain the full working. For now, the outcome is the one that matters: once the AI has been paid to think, nobody pays again to look.

07No swarms: fifteen minutes and a steering wheel

Welcome to the swarm of agents. We think this concept is a disaster. Why would you want so many agents running for so many hours? Even the final result will be left unattended, because the person who asked went home.

In two years of running AI on real business work, we have not found a single task that took more than fifteen minutes to finish. If you have a list of tasks that will take longer, do not spawn agents — start steering. Read the thinking as it streams. Correct the first wrong assumption when it is one sentence old. It will be done in five.

Hence at E1pi there are no unattended workflows. We display the main thinking, the tool thinking and every tool call, and we want you to watch them — not because the AI is bad, but because the best frontier models still make silly mistakes that are very hard to trace afterwards and very easy to correct while they happen. A human starts the run, a human steers it, a human approves what leaves.

08Not convinced? Let’s talk money

Our rule is simple. Once we have paid for the input tokens, we want the maximum work out within five minutes. Every extra agent you open pays for that context again.

Here is why swarms are expensive in a way the demos never show. On the frontier models we lived with, an output token cost roughly five times an input token — the ratio at the time was about USD 10 against USD 50 per million. A parent agent that briefs child agents has to hand each of them the task, the data and the context. It converts input into output. What it read at one times, it now writes at five times — once per child. Then it reads all their answers back and writes a summary. The children, meanwhile, each read the brief and write their own output.

We have all worked with the government-office version of this. Managers of managers of managers of managers, until in the end everyone has forgotten the task they were supposed to do. A swarm is that org chart, billed per word.

09E1pi wrote E1pi

Though it was never the intention, E1pi wrote E1pi. Not one member of the team has used Visual Studio Code or Xcode for the iOS and macOS apps. I have coded E1pi while sitting in a sauna, while stuck in traffic, and in a movie hall — and all three platforms, web, iOS and macOS, came out of those sessions. The harness was the only development environment, and the phone in my hand was the only screen.

The last stray: iOS

An iPhone will not display a desktop-sized website; it insists on a phone layout. We did not want two products. So the iPhone app wraps the full E1pi in a native web view, and the same page serves the phone and the desktop — drawer, feed, composer, approvals, all of it. The Mac app does the same. It is one E1pi, on every screen.

One Mac, seven Windows PCs

Only one person on the team used a Mac; everyone else was on Windows. Building an iPhone app with seven people who cannot run the simulator sounds like a blocker. It was not. We streamed the simulator, and the team watched the AI build, run and fix the app live — then steered it from their own machines. The simulator ended up inside E1pi’s own web drawer, so the AI’s iOS work could be checked without leaving the conversation.

10What the harness became

Every principle above is now a feature on the AI Harness section of the website. In one list:

• One subscription, the whole team. One harness, one frontier-model subscription, every person signed in as themselves.
• Every device, the same E1pi. Browser, iPhone, Mac, Windows, Teams and WhatsApp — one page, wrapped natively.
• Skills, not rigid schemas. Readable documents the admin edits; the AI follows a minute later.
• Pipe HTML. The AI instructs, the harness runs, the browser draws. A second look costs nothing.
• Thinking in the open. Main thinking, tool thinking, every tool call, live. Steer it.
• One agent per request. Never a swarm, never unattended, never billed five times for the same context.
• Everything on record. Who asked, what the AI did, who approved — one feed per person an auditor can read.
• One admin in control. Companies, reports, Skills and approval limits per person; tasks assigned in a sentence.

After two years, even as the people who built it, we have discovered only a tiny fraction of what this way of working makes possible. We keep learning from it daily. The one thing we are sure of is the shape: a person starts it, a person steers it, a person holds the pen.