Level 1 — Basic Responder: The Human Guides the Entire Flow

Level 1, Basic Responder, is the starting point of the 5-level autonomy progression, and it's less an 'agent' in any meaningful sense than it is an LLM being called as a plain function inside a human-designed program. A human guides the entire flow: what gets called when, what happens to the output, and what the next step is are all decided by the surrounding code, not by the model.

At this level, the LLM is a generic responder — it receives an input and produces an output, and that's essentially the full extent of its role. It has little to no control over the program flow: it doesn't decide whether to call a tool, doesn't decide what happens next, doesn't maintain any memory of prior calls unless the surrounding code explicitly re-supplies that context. Think of a single API call — 'summarize this document,' 'classify this support ticket,' 'translate this sentence' — where the application code decides everything before and after that one call.

This is not a lesser or 'wrong' way to use an LLM — it's simply the appropriate level for tasks that genuinely are single-step, well-defined transformations with no need for the model to make any decisions about flow or tool use. Many production LLM features (classification, summarization, translation, simple extraction) operate perfectly well at Level 1 and gain nothing from the added complexity of the levels above.

The progression from here up through Level 5 is fundamentally about how much control shifts from the human-defined program flow to an LLM-defined one — Level 1 represents the human keeping essentially all of that control, with the LLM contributing only its language understanding and generation capability to one isolated step in a flow the human designed start to finish.

from openai import OpenAI

client = OpenAI()

def level1_basic_responder(document: str) -> str:
    """Level 1: the LLM is a pure function call. The surrounding code
    (not the model) decides everything about the flow — there's exactly
    one call, with no branching, tool use, or follow-up decided by the LLM."""
    resp = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{"role": "user", "content": f"Summarize this document in 2 sentences:\n\n{document}"}],
    )
    return resp.choices[0].message.content

# The human-written code around this call decides everything else —
# where the summary goes, whether to retry, what happens next. The
# LLM itself has zero say in any of that.
summary = level1_basic_responder("...")
save_to_database(summary)  # a plain, human-designed next step