The transfer switch moves current. Somebody still has to decide what runs.
sleds is the layer that knows the work: what it is, who should do it, what it should cost, what came back. Simple sentences, one idea each. This is the list.
- AI defines work faster than any team can decide it.
Specs write themselves in an afternoon; agents return PRs overnight; it lands on engineers faster than they can absorb it.
- Work is no longer scarce. Deciding it is.
- No one in the org knows how long anything takes anymore.
One team 10x'd its lines of code in a year and stopped estimating.
- Compute has walls: quota, credits, cost, availability.
They change the answer to "who does this". They are not the point.
- Product, design and engineering are blending.
Business users are moving toward engineering; engineers are not moving the other way. Nobody serves the seam where the prototype becomes the ticket becomes the PR.
- Everyone has intelligence in their lap.
Claude and ChatGPT are open on every desk. The head of the tracker is already theirs; the record is what is missing.
- Every vendor is building a version of this for its own agent.
Nobody is neutral across agents and people.
- Enterprises will not let their code or prompts be seen or kept.
Trust is a precondition, not a feature.
- We are the dispatcher.
Every unit of work is assigned to a seat, an agent, a model, a person, a time, and comes back with a signed record.
- We price the work before it runs and record what it actually cost after.
Estimate versus actual, per task type, per model, per repo, is the ledger.
- We attest what came back.
Which model built it, when, what it produced. Signed, without holding the content.
- We are the tracker, headless.
The record is ours to keep. The head is whatever AI the person already has open. We never build a form.
- We hand work between seats.
To a teammate, to a buddy on another platform, to tonight's batch, to the reset, to the platform key within an allowance.
- We take the flood and give the engineer a list.
Now, background, which model per step, overnight, a teammate who owns that area, not worth doing.
- We read the three rails and treat a wall as one more input.
Platform API key, seat quota, seat credits, for every platform a seat uses.
- We reach the person where they already are.
The status line, the next prompt, the cockpit sidebar and ring, Slack, the extension, the conversation.
- We write back to the tracker in the tracker's own words.
And let the ledger become the record of work underneath it.
- We install in one line and never ask an engineer to integrate anything.
- We keep the numbers and never the prompts or the code.
What must carry content is switchable and expiring.
- We learn from real backlogs.
What a "3-point" ticket actually cost when an agent did it. Better with every new model.
- Gateways route requests. Trackers store tickets. Agents take a task and return a diff.
Vendors route models inside their own agent. We decide which seat gets the work, across all of them.
- We are not a harness.
The harness routes within the run; the dispatcher routes between runs and between seats.
- We are not the tracker's assign button.
The tracker can assign the work to an agent; it cannot say what it will cost, whether the seat can take it, or prove what came back. We take the assignment as an input.
- What a vendor's board cannot have: a price before, an attested record across vendors, a person as a dispatch target.
What we will never have and never need: our own coding agent.
- The customer's agents, models, keys and trackers are theirs.
We are the layer that makes them one set of books.
- The dataset nobody upstream can build gets more valuable with every model release.
Estimates versus actuals across agents, models and people. Including from our own PRs.
- On the engineer's side.
Their laptop, their install, their numbers. Leads see aggregates. Nothing ranks people. If a VP screenshotted a screen and an engineer would feel graded, it doesn't ship in that shape.
- One view, three zooms.
Manager and engineer see the same screens; persona is scope, grain and redaction, never a second app.
- Priced before, attested after.
For customers and for ourselves. Every PR we ship carries its estimate and its actual.
- Every wall is an input, not the point.
The policy decides the exit, not the person at 2 am.
- Neutral across vendors.
Use the exchange; never build model access; never become the system of record by force.
- Trust by architecture.
Stream, don't store. Aggregates leave the laptop; raw data doesn't. Say precisely what we keep.
- One line to install.
Identity from the laptop, the workspace and WorkOS; nothing for the engineer to configure.
- Simple, with rough edges.
Ship the plain version, leave empty states plain, never leave a headline number blank.
- Words matter.
Dispatcher, not router. Workspace, account, seat. Headroom, never a word that grades a person. Three rails, never one word.
- Additive, then distill.
New thinking gets written down verbatim first; the sentence gets shorter later.
- Enterprise engineering orgs, tens to hundreds of seats, where AI defines work faster than the team can decide it.
- The buyer is the platform or DevEx lead, with finance beside them.
- The user is everyone with a seat who builds.
Engineers, and the product and design people now building beside them.
- The asker is everyone else.
Anyone with an idea and a Claude tab. Intake is free for the whole company.
- The wedge is one engineer, one line. The expansion is the team, then the dispatcher. Same code.