← Data Into Labor · All essays

Data Into Labor · Essay 03 · V2

The Moby Harness, Primitives, and Tools

July 2026 · AJ Orbach

It's hard to predict what software will look like in ten years. Agents are an exception, because with agents you can reason about the curve instead of the snapshot. Model prices fall on a schedule. Task horizons stretch every generation. Every lab's engine improves whether you do anything or not. Accept those three trends and a surprising amount of agent design gets decided for you. You stop asking "what should we build for today's models?" and start asking "what shape does the harness converge on?" Then you build that shape now.

Moby is what fell out when we took the curve seriously. It's a harness: the machinery you build around intelligence so that intelligence can do work — the data it can reach, the memory it keeps, the computer it uses, the surfaces where its work takes shape, the hands with which it acts, and the ledger that records everything it did.^[1] The frontier labs build engines, and the engines are magnificent, and they're for sale to everyone at the same price. But an engine is not a vehicle. Nobody commutes to work on a crated V8. The vehicle is everything built around the engine, and that's where we decided to spend our years. The weights are rented. The harness is owned.

Concretely, Moby is thirteen deliberate decisions, made in sequence, each one a bet about where agents are going. Some looked strange when we made them. What the decisions produced is a small set of primitives — artifacts, apps, automations, specialists — and the tools that give them reach. Here's the list, and the reasoning.

Brains

The first decision was to refuse to marry a model. It sounds like a technical footnote; it's actually a worldview. The best reasoning model this month will be second-best by fall, and the model that costs a dollar today will cost a dime next year. A harness married to a single lab ages like a phone contract. So Moby uses all the best models, and the right model for each job: a gnarly multi-step reconciliation gets the heaviest reasoner available, a thousand-row labeling pass gets something fast and cheap. The user should never have to think about this; the harness should. This is also the honest answer to the question every AI company gets asked — what happens when the models get better? For us, everything gets better. We built the vehicle that gets faster every time anyone, anywhere, builds a better engine.

The second decision was to make text-to-SQL actually work. As usually practiced it's a parlor trick: a model guessing at a schema it has never seen, producing an answer that's plausible, confident, and wrong. Our version is called Get Data, and it required unglamorous engineering on both sides of the problem at once — on the tables, so the schema an agent reads tells the truth about the business, and on the loop, so the agent inspects, queries, checks its own results, and retries instead of firing one query into the dark.^[2] The bar isn't "an answer." It's the number you'd defend in a board meeting. An agent that's right about your business ninety-nine times out of a hundred gets handed real work. An agent that's right most of the time gets handed nothing, and deserves it.

Memory

The third decision was to build an elaborate memory system and give it a subconscious. Moby's memory consolidates in the background, a process we call dreaming: while nobody is asking it anything, it digests what happened, keeps what mattered, and files it where it will be found again.^[3]

What makes the system unusual is where it remembers. Memory lives at four strata: the user level knows how you like your reports, the workspace level knows the state of a project, the channel level knows what a team is working through, and the business level — the radical one — is shared. Because memory compounds at the business level, every person in the organization who talks to Moby is training the same colleague. The analyst's correction in March saves the marketer a wrong answer in June. It's one conversation the entire company is having with one intelligence, and the hundredth employee inherits everything the first ninety-nine taught it. On top of the warehouse, this system lets Moby operate over hundreds of thousands, even millions, of files per business: contracts, briefs, reports, past work, decisions and their reasons.

Hours

The fourth decision was made against the curve rather than the snapshot. Task horizons keep stretching — models in the class of Fable 5.6 can hold a thread of work for a very long time, and every generation holds it longer.^[4] An architecture built for five-minute exchanges would have been obsolete on arrival, so we did the infrastructure work to let Moby run for hours on a single task. That forced a second choice, among the most important we made: Moby is cloud native. A local agent dies when the laptop lid closes; it works only while you watch it, which makes it a fancy cursor. A cloud agent keeps working after you've gone home. Hand it something at five o'clock and the work is on your desk in the morning. That's not a feature of an assistant. It's the defining property of an employee.

The fifth decision sounds almost childishly simple: we gave Moby a computer. Real machines it can spin up on demand, to run code, process files, build things, and — crucially — check its own work. QA is not a prompt; it's an act. An agent with a computer can open what it just built, look at it, find the flaw, and fix it before you ever see it. A language model without a computer can only talk about work. With one, it can do work. That's the difference between a consultant and a contractor, and combined with the cloud decision the two multiply: hours-long tasks with self-verification, the kind of work that used to be a project plan, a kickoff meeting, and a two-week wait.

Surfaces

The sixth decision started as an observation: somewhere along the way, the models became natively, startlingly good at HTML. Most products treated that as a curiosity. We leaned in as hard as we could, and Moby learned to build genuinely beautiful artifacts — reports you'd forward to your board. Then the artifact turned out to be only the first form. The second is the stateful app: a report is something you read, an app is something you use. And a super agent plus stateful apps yields something new — custom internal software, built by asking for it. The tracking tool your ops team always wanted. The dashboard that matches how your team actually thinks. Software with a market of one was never economical to build, until the marginal cost of building it fell to a conversation. We think this is a superpower, and that the artifact-to-app path becomes a core primitive of agents everywhere.^[5]

The seventh decision was the next primitive: the automation, and the name undersells it. An automation is a stateful loop that can orchestrate entire swarms of agents: dispatching parallel workers, collecting results, keeping state between runs, carrying context from each cycle into the next.^[6] This is what turns Moby from a colleague you talk to into a colleague with standing responsibilities — the buyer that reviews performance on schedule and executes what it's authorized to execute, the creative loop that studies what worked and routes the next batch for approval. It's genuinely astonishing how much of a business's recurring work fits inside that shape.

The eighth decision follows from an observation about businesses: a business is not one job, it's fifty jobs wearing one logo. So Moby organizes the same way. A specialist is a slice of context around one job to be done — its own automations, chats, dashboards, and skills, everything that belongs to the job and nothing that doesn't. The retention specialist doesn't wander into media buying; the finance specialist doesn't wander into creative. And a specialist can be connected to a specific Slack channel, which puts the job's context and the team that cares about it in the same room.

Which is the ninth decision: move into Slack like an employee. Properly — the way Claude or Perplexity show up in Slack, not a notification bot with a slash command bolted on. The bar for native is awareness: the threads, the context, the decisions being made in the channel while it watches. You tag it the way you'd tag a teammate, and it answers with everything the channel has discussed, everything the connected specialist knows, and everything the business memory has accumulated. You don't onboard it. It saw the conversation.

Hands

Intelligence that can't touch the world is commentary. The tenth decision was to connect Moby to the world in two deliberately different ways. Data integrations feed the warehouse: orders, spend, sessions, subscriptions — the shared, normalized facts of the business. User-level integrations are newer and more personal: Gmail, HubSpot, Zoom, Notion. Those don't feed the warehouse. They let Moby act as if it were you, with your access, inside your tools — draft the follow-up from your inbox, pull the notes from your call, update the record in your CRM. The business's facts belong to the business; your reach belongs to you. Moby respects the line and works both sides of it.

The eleventh decision separates an advisor from an operator: actions. As of this writing there are on the order of five to six hundred of them, across Shopify, Klaviyo, Amazon, Meta, and Google — budgets changed, campaigns adjusted, flows drafted, listings updated.^[7] But the count is the less interesting half. The more interesting half is the ledger. Every action is logged at four altitudes — session, workspace, automation, shop: what happened in this conversation, what happened in this project, what the loop did while you slept, what changed across the whole business. And Moby is aware of its own logs, which means it knows what it did, can explain why, and won't do it twice. An agent that can't show its receipts is a liability with initiative. Nobody hands the keys to a system they can't audit; the paper trail is precisely what makes it rational to let the machine act at all.

The twelfth decision: tools built for the territory. A general intelligence with generic tools gives generic advice. Moby carries instruments built for commerce — forecasting models, so "what happens next quarter" is an analysis rather than a vibe; revenue and incrementality models, so "did that spend cause anything" has a defensible answer; competitor ads, so the market is in the room; and ten more purpose-built tools alongside them.^[8] A surgeon with a Swiss Army knife is still not equipped. Depth of tooling in a domain is what turns intelligence into judgment there.

The thirteenth decision may be the most visible: we went all in on creative. Moby gets the latest creative models as they ship — Seedance for video, GPT Image 2, Nano Banana.^[9] That's the same frontier everyone else can rent. What everyone else can't rent is the other half: the performance data behind your ads and landing pages, already sitting in the warehouse, normalized and queryable. So the workflow collapses into a sentence — pull my top ads, and make me new ones like them. The creative models provide the hands. The performance data provides the taste.

The sum

Read back over the list and a shape emerges. A brain never more than a quarter behind the frontier. Ground truth from your own warehouse, answered correctly. A memory that compounds across every person in the company, consolidated while nobody watches. A body that lives in the cloud, works for hours, and owns a computer. Work that arrives as artifacts and grows into software. Standing responsibilities that run as loops commanding swarms. Context organized by job, present in the room where the team already talks. Hands in the business's data and hands in your own tools, with every action on the record at four altitudes.

No single decision on the list is the product. Several of them, alone, would be a nice feature in someone else's product. The product is the compounding: the memory makes the automations smarter, the ledger makes the actions permissible, the computer makes the artifacts real. Each decision makes the other twelve more valuable. That compounding is what we mean by a harness.

And this is where reasoning about the curve pays off. If you can see the shape that serious agents converge on — and we believe this is that shape — then the right move is to build toward it before the snapshot demands it, and let every quarter of model progress land on machinery that's ready for it. Moby is not a model. Models come and go quarterly, and ours will keep changing with them. Moby is the thirteen decisions. That's the machine we mean when we say the sentence this whole series keeps arriving at: data stops being something you look at, and starts being something that works for you.