orchestrate-agent-architecture

Orchestrate Agent Architecture

HackerRank's own description of the code rubric is unusually specific and worth quoting directly: it measures "whether submissions contain actual agent loops versus hardcoded workflows." That is a stated, explicit discriminator. It's also the single easiest place to lose 30% of your score while producing something that technically works.

The hardcoded-workflow trap

Under time pressure the tempting shape is:

for ticket in tickets:
    category = classify(ticket)          # one LLM call
    if category == "billing":
        urgency = check_billing_rules(ticket)
    elif category == "technical":
        urgency = check_tech_rules(ticket)
    ...
    if urgency > THRESHOLD:
        escalate(ticket)
    else:
        respond(ticket)

This can score well on raw correctness and still read as a decision tree with LLM calls embedded in it, not an agent. Every branch was decided by you, at authoring time. The model fills in blanks; it doesn't decide anything about how to approach the problem.

What an actual agent loop looks like

The distinguishing property: the model decides what to do next, and the loop continues until the model says it's done — rather than the control flow being fixed in advance by the author.

def run_agent(ticket, tools, max_steps=10):
    messages = [system_prompt(), user_prompt(ticket)]
    for step in range(max_steps):
        response = model.call(messages, tools=tools)
        if response.is_final_answer:
            return response.answer
        result = execute_tool(response.tool_call)   # agent chose this tool
        messages.append(response)
        messages.append(result)
    return fallback(messages)   # hit step limit — handle explicitly

The agent chose: which tool, with which arguments, how many times, and when to stop. That's the thing being scored.

This is not an argument for maximum autonomy. A loop that wanders for 40 steps is worse than a tight pipeline. The point is that the structure should let the model make decisions where judgment is genuinely required, with bounded steps and explicit fallbacks — not that you should remove all structure.