How AI Agents Are Changing Software

A chatbot answers. An agent acts. The difference sounds small but it reshapes how software is built. An agent is a loop: observe, reason, choose a tool, execute, observe again — until the task is done or the agent decides to hand back to a human.

The agent loop

Every agent framework reduces to the same core cycle. The model receives an observation, produces a thought and a tool call, the runtime executes that call, and the result becomes the next observation.

// the entire agent loop, in essence
async function runAgent(task, tools, model, maxSteps = 12) {
  let messages = [{ role: 'system', content: task }];

  for (let step = 0; step < maxSteps; step++) {
    const reply = await model.complete({ messages, tools });

    if (reply.tool_calls.length === 0) {
      return reply.content; // agent is done — natural-language answer
    }

    messages.push(reply); // record the assistant's decision

    for (const call of reply.tool_calls) {
      const result = await tools[call.name](call.arguments);
      messages.push({ role: 'tool', tool_call_id: call.id, content: result });
    }
  }
  throw new Error('agent exceeded step budget without converging');
}

Tools are the product

The model is a commodity. The tools are not. A well-designed tool surface — narrow inputs, predictable outputs, clear failure modes — is what separates an agent that ships from one that hallucinates in circles. Treat each tool like a public API: name it precisely, document the schema, and return structured data the model can reason over.

The model decides. The tools do. Most agent failures are tool-design failures wearing a model costume.— Orchestration Group

Guardrails and budgets

Autonomy without limits is a liability. Every production agent needs a step budget, a cost ceiling, and a human escalation path. The step budget prevents infinite loops; the cost ceiling prevents a runaway task from burning a month of tokens; the escalation path is what makes a human trust the system enough to deploy it.

The agents that change software are not the ones that promise full autonomy. They are the ones that do 90% of the work, then stop and ask — with a well-argued case — for the last 10%.