Hi, I'm Varun.

The chef is the talent.
The kitchen is the harness.

A kitchen is everything around the cook that turns raw talent into dinner — on time, every night. An agent harness is the same thing around a model: the model can reason, but the harness is what turns reasoning into work you can serve. Swap the chef — the kitchen still ships dinner.

A new resource to manage.

For decades, backend meant three resources — and each earned a management layer. Intelligence is the fourth: metered, it scales and throttles, and it fails in new ways. The harness is how you manage it.

You never manage a resource
by hand.

Each layer allocates the resource, hides its failure modes, and hands you a clean interface. The harness is that layer for intelligence.

Build it once.
Reconfigure forever.

Held constant: the loop. The only thing that changes is the configuration — skills, tools, the system prompt. Same engine, different passes.

Every talk today is
a different harness.

• LangGraph — stateful, graph-shaped Dhananjay
• WebMCP + Angular — a harness in the browser Shaikh
• Cost & tokens — the same harness, tuned for the bill Sumit
• Mine — the same loop, driving a truck Varun

Same loop. Different configuration. You'll watch this thesis play out all morning.

Not one loop. A few.

We'll build #1 live. #2 is where guardrails and evals live — a loop wrapped around the loop.

const tools = {
  read_file: {
    description: "Read a UTF-8 file and return its contents.",
    run: ({ path }) => fs.readFileSync(path, "utf8"),
  },
  write_file: {
    description: "Create or overwrite a UTF-8 file.",
    run: ({ path, content }) => {
      fs.writeFileSync(path, content);
      return `wrote ${content.length} bytes to ${path}`;
    },
  },
};

Two tools. Each is a schema for the model plus a function we run.

async function run(task) {
  const messages = [
    { role: "system", content: SYSTEM },
    { role: "user", content: task },
  ];

  for (let step = 0; step < 10; step++) {
    const { msg } = await callLLM(messages);            //~ think
    if (!msg.tool_calls?.length) return msg.content;    //~ done

    messages.push({ role: "assistant", tool_calls: msg.tool_calls });
    for (const tc of msg.tool_calls) {                  //~ act
      const args = JSON.parse(tc.function.arguments);
      const result = tools[tc.function.name].run(args);
      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
    }
  }
}

Count the lines. ~20. That's loop #1 from two slides ago — the whole agent loop. Everything else is what makes it survivable.

One line each. A whole talk each.