Building a Mentor, Not a Bot: From Linear Chains to Feedback Loops

For the last two years, "prompt engineering" was the main event. It was fun, messy, and creative. While it had structure, the outcomes were rarely consistent enough to ship with confidence.

In the Google & Kaggle AI Agents Intensive Course, I learned that this era is ending. We are entering the era of Agent Engineering.

But what does this mean for developers used to traditional software where you write 1 + 1, the output is always 2?

AI Agents, however, are non-deterministic; launching the exact same prompt twice can yield two completely different trajectories. This unpredictability manifests in several critical failure modes: the agent might drift off course (Hallucination), burn all its fuel spinning in circles (Loops), or encounter an asteroid field (API Timeouts).

Because of this, we have to stop optimizing for the Output (The Black Box) and start optimizing for the Trajectory (The Glass Box).

The "Mission Control" Framework

To handle this unpredictability, you need a framework. To move from Prototype to Production, your telemetry must cover four pillars of a successful mission:

1. Effectiveness (Did we land on Mars?)

This is your primary success metric: Task Completion. Think of it as the pass/fail state for the entire run. Specifically: Did the agent fully resolve the user's intended task? A highly conversational agent that returns a perfect, charming response but fails to integrate with the required external API is a critical mission failure.

2. Efficiency (Fuel Management)

Did you reach orbit, or did you burn your entire tank on the launchpad? Efficiency tracks your "burn rate"—tokens, latency, and steps.

Rule of Thumb: If your agent takes 50 "thoughts" and $\$2.00$ in API credits to answer a simple "Hello," you need to abort the launch.

3. Robustness (Structural Integrity)

Space is hostile. APIs fail. Data is messy. A robust agent has backup systems. When it hits an error, it shouldn't crash or hallucinate a fake reality—it should correct its course, retry, or signal for help.

4. Safety (Containment Protocols)

Safety ensures your agent respects the "flight corridors" (Guardrails). It must never leak data, accept prompt injections, or execute harmful commands.

Case Study: From Assembly Line to Feedback Loop

The original design of the multi-agent system used a Linear Chain (Architect \ Tutor \ Reviewer), functioning like an assembly line where failure at any step stopped the process. To better enforce deep logic and prioritize iterative refinement, we refactored the system from a strict chain into a Self-Correcting Loop.

1. The Architecture Shift: Break the Chain

This rigid chain doesn't teach; it just processes. To mimic a real senior developer, we need Iterative Refinement. We moved the Tutor and Reviewer inside a LoopAgent.

graph TD
    User(Student Input) --> Generator
    subgraph "The Loop"
        Generator[Tutor Agent] -->|Draft Code| Critic[Reviewer Agent]
        Critic -->|Feedback| Gate{Pass Standards?}
        Gate -->|No: Specific Critique| Generator
    end
    Gate -->|Yes| Success(Final Grade)

This diagram illustrates an iterative feedback loop where the Tutor Agent initially processes student input to create a code draft. A Reviewer Agent immediately critiques this draft; if it fails to meet quality standards, specific feedback is looped back to the Tutor for refinement. This cycle of correction continues automatically until the logic satisfies the Decision Gate. Once the standards are met, the process concludes with a final grade.

• The Generator (Tutor): Prompts the student for code.
• The Critic (Reviewer): Grades the logic/style.
• The Loop: If the code fails the "Senior Dev Standard," the system rejects it and sends it back to the Tutor with specific feedback.

2. Smart Routing: Flash for Speed, Pro for Brains

We used Model Routing to balance the budget (Efficiency). We reserve the "heavy compute" only for where it matters.

Here is the pseudo-code logic for the router:

def agent_loop(student_code, max_retries=3):
    attempts = 0

    while attempts < max_retries:
        # 1. FAST & CHEAP: Interactive Chat
        # Use Gemini 2.5 Flash for high-speed, low-cost iterations
        refined_code = tutor_agent.generate(
            context=student_code, 
            model="gemini-2.5-flash"
        )

        # 2. SLOW & SMART: The Judge
        # Use Gemini 3 Pro for deep reasoning and subtle bug detection
        feedback = reviewer_agent.evaluate(
            code=refined_code, 
            model="gemini-3-pro"
        )

        if feedback.status == "PASS":
            return feedback.output

        # 3. FEEDBACK INJECTION
        # Pass the 'Pro' insights back to the 'Flash' agent
        student_code = f"Previous attempt failed: {feedback.critique}. Try again."
        attempts += 1

    raise MaxRetriesExceeded("Student needs human intervention.")

3. The Trajectory is the Teacher

By moving to a loop, we gained a massive advantage: Observability.

In a linear chain, you just get a final score. In a loop, you get a Trajectory. We can trace the student's entire struggle—how many attempts they took, where they got stuck, and how they fixed it.

• Logs: Capture the raw code attempts.
• Traces: Show the causal link between the Reviewer's feedback and the student's next move.

We are no longer just "coding" instructions; we are directing autonomous systems. The ground is shifting from creation to control.

By shifting from a straight line to a "Think, Act, Observe" loop, we stopped building a quiz bot and started building a mentor. The agent doesn't just grade; it guides until the mission is accomplished.