Harness, loop, graph: what years of enterprise delivery taught us about AI that ships
Enterprise AI pays off when it adds capacity without adding risk, and in most pilots the thing in the way is not the model. It is a person. Someone copies output from one system into another, checks whether it is right, and decides what should happen next. In the demo it looks automated. In practice, a skilled employee is still holding the process together by hand.
That person is covering for three things the system is missing: a safe place for the AI to work, a reliable way to prove the work is right, and clear rules for what happens next and who signs off.
We call these the harness, the loop, and the graph. Get them right and the business gets more capacity from the same team, faster cycle times, and mistakes that stay small and cheap.
Most of these lessons are older than AI. We learned them over years of enterprise delivery with clients like AAA, John Hancock, Manulife, and Ford, long before anyone said "agent." We learned them again when we built our own multi-agent platform. Here is what carried over, and the practical tips we use today.
The harness, loop and graph framing comes from a post by @m4lkxx on X; the lessons below are ours.
1. The harness: give the work a safe place to happen
Old way. Someone pastes a request into a chat window, moves the answer into the real system by hand, and reports back when it fails.
New way. The AI works inside your real systems, with only the access the task needs, and keeps its notes somewhere that outlasts the conversation.
Mechanism. The harness is everything around the model: the tools it can use, the permissions it holds, where it records progress, and the limits on time and spend. Think of it as the job description, the building pass and the expense limit you would give a new hire.
What we learned
When we built our own enterprise agent platform, we built the shared runtime and the memory layer first, before any specialized agent. Each agent got only the tools its task required. Company knowledge was kept separate from each agent's working memory, which made answers easier to trust. Privacy controls, audit trails, and human review were part of the design from day one. (Source: TribalScale enterprise agentic platform case study)
The platform runs on events and schedules instead of always-on services, and it operates for roughly $20 to $40 a day. (Source: same case study)
Tips to make your harness better
Give the AI only the tools this task needs. More tools means more chances to pick the wrong one. A short list of clearly described tools works better than a long list that overlaps.
Enforce limits in access rights, not in instructions. Telling an AI to stay out of payroll data is not a control. Removing its access is.
Keep memory outside the conversation. Keep a running record of the goal, the decisions made, and the off-limits areas in a file the AI reads at the start of every session, so work survives a crash or a handoff.
Set hard caps on time and spend. Every run needs a spending limit.
Log every action. Your risk and audit teams should be able to see what happened without reading a transcript.
2. The loop: make "done" mean something
Old way. The AI says it is finished, and a person reviews everything to find out whether that is true.
New way. Before work starts, the team writes the check that decides whether the work is finished. The system runs that check itself, every time.
Mechanism. Every loop does the same thing: the AI produces work, a check judges it, the AI corrects, and the cycle runs again. All the value sits in the check.
What we learned
This is the oldest lesson in our playbook. We learned it building software with enterprise teams, and it applies even more to AI, because AI can produce work far faster than people can review it.
At AAA, our engineers paired with AAA engineers and brought in test-first development and an automated test and release pipeline. Time to market went from 8 to 12 months down to 2 to 4 months. (Source: AAA case study)
At Ford's autonomous vehicle unit, automated tests ran on every code submission, and more than 200 defects were caught and fixed before production. (Source: Ford autonomous vehicle case study)
At Manulife Bank, test-first development covered 90% of the code over a 16 week engagement. (Source: Manulife Bank case study)
At John Hancock, automated testing and delivery pipelines supported a new portfolio workflow that cut portfolio creation from 10 minutes to 2 minutes. (Source: John Hancock case study)
None of those engagements were about AI agents. The discipline that made those teams fast is the same discipline that makes AI work trustworthy.
Tips to make your loop better
Write what "done" means before the AI writes anything. If the team cannot agree on the check, the requirements are not finished yet.
Test the test. Give it work you know is wrong and make sure it says so.
Rank your evidence. Automated tests and rules first. The record of what actually ran second. An independent reviewer third. The AI's own confidence last.
Make failures specific. Feedback should say what was expected, what actually happened, where it went wrong, and which fixes were already tried.
Set exits. Stop and escalate when the same failure comes back twice or the budget runs out. When the same error repeats, the problem is usually how the task was defined, not effort.
3. The graph: shape the work, and match sign-off to risk
Old way. Every step waits for the one before it, and every output gets the same review, whether it is a formatting fix or a change to a customer's account access.
New way. Split the work into independent pieces that can run side by side. Check each piece as it finishes. Decide who signs off based on business risk.
Mechanism. A graph has three parts: steps (each one bounded job), links (a real dependency between steps), and the state that carries from one step to the next. Each step gets its own checkpoint, so a problem is caught while it is still small.
What we learned
For NBC News, we built one app per brand per platform and kept leadership close through a weekly review rhythm. Nine branded streaming apps launched in five months. (Source: NBC News case study)
In our own agent platform, the proposal agent hands parts of the job to specialized sub-agents, and case study drafts arrive as pull requests that a person reviews. Case study creation went from days to about 15 minutes. (Source: TribalScale enterprise agentic platform case study)
Tips to make your graph better
Challenge every handoff. Ask whether the next step truly needs the previous one to finish. If it does not, run them side by side and stop paying for the wait.
Use ordinary software where the answer should never change. Calculations, lookups, and formatting belong in regular code. Save AI for steps where judgment is the job.
Lock approved pieces. When one piece fails, redo only that piece. Approved work should stay approved.
Match sign-off to the business risk. A draft can move on its own; a payment, a deletion or a customer message needs a named owner.
Keep senior reviewers for high-stakes calls. Senior time is expensive. Do not spend it on work that can be undone in a click.
Turn incidents into fixes
Treat an AI mistake the way a good operations team treats an outage: find the cause, then change the system so it does not happen again. Usually that means tighter access, a new automatic check, or a different way of splitting the work. Fix the system, not the instructions.
How to start
Pick one workflow that matters to the business, and write down what a correct result looks like before anyone builds anything.
That one definition tells you what access the AI needs, what to check automatically, and where a person has to sign off. Not every workflow needs all three layers on day one. Add a layer when the business case is clear.
What this means for leaders
Harness: the AI can do real work, safely.
Loop: you can trust what it produced.
Graph: work moves fast, and people sign off only where it matters.
Learning: fixed problems stay fixed.
The aim is not to remove your people from the work. It is to stop spending them on copying and checking, and to put their judgment where a mistake would be costly. That is what an AI-Native enterprise looks like in practice: strategy that ends in production.
Bring us the problem. We bring the team that gets it into production. Talk to TribalScale at tribalscale.com