From automation to AI agents

Automation has always been about the same thing: take something repetitive and make it reliable. Scripts replaced manual clicks; pipelines replaced manual deploys. AI agents extend that idea to tasks that used to need human judgment.

An agent is just automation with reasoning

A classic automation follows fixed steps. An agent decides the steps. Give it a goal, a set of tools and a feedback loop, and it plans, acts and adjusts.

def run(goal: str, tools: dict, max_steps: int = 8) -> str:
    history = [f"Goal: {goal}"]
    for _ in range(max_steps):
        action = model.decide(history, tools.keys())
        if action.kind == "final":
            return action.answer
        result = tools[action.tool](**action.args)
        history.append(f"{action.tool} -> {result}")
    return "Stopped: step budget exhausted"

Treat agents like flaky systems

This is where years of quality engineering pay off. Agents are non-deterministic — the same input can take different paths. So I apply the same discipline I learned from test automation:

• Bound them. Step budgets and timeouts, exactly like a flaky test guard.
• Verify outputs. Don't trust; assert. Validate structure and constraints.
• Make them observable. Log every decision so failures are debuggable.
• Keep a human in the loop for anything irreversible.

Where this is heading

For Felivo, this is the roadmap: agents that surface health insights from a pet's records and flag patterns a busy owner might miss — assistive, bounded and verifiable.

The skills transfer cleanly. Making AI dependable is a quality-engineering problem, and that's a problem I've spent years learning to solve.