Agent As a Function

Agents can work like functions too.

TL;DR

1. Traditional functions are procedure-driven: they execute a predefined algorithm. The path is fixed when we write the code.
2. Autonomous Functions are goal-driven: they use reasoning, tools, and validation loops to discover a path toward the goal during execution.
3. In this sense, an agent can be viewed as a function whose internal computation is adaptive rather than fixed. You define the goal via system prompt, provide validation rules and tools, and let it iterate until the goal is reached.

A traditional function is defined by its procedure. sort(arr) specifies how to do the work: the algorithm is written out step by step, and the function executes it the same way every time. We decide the path when we write the code; at runtime it just runs.

But some problems are easier to state as a goal than as a procedure. book_cheapest_flight() says what to achieve, not how. Which sites to check, how to compare them, when to stop. These steps can’t all be known when we write the code. They have to be worked out while the function runs.

What if a function could do that working-out itself? Take a goal, reason about how to achieve it, try a strategy, check the result, try something else when it fails, and decide for itself when the task is truly complete?

I call this pattern “Agent as a Function,” and the function it produces an “Autonomous Function.” A traditional function executes a predefined algorithm; an Autonomous Function discovers the algorithm during execution. Where a traditional function follows a fixed trajectory, an Autonomous Function searches for one. It reasons, calls tools, validates its own work, and iterates until the goal is reached.

Let me show this with a concrete example. Imagine we need a function that downloads a dataset from HuggingFace and normalizes it to OpenAI message format.

Approach 1: Single LLM Call

def normalize_dataset(dataset_name: str) -> list:
    return llm.complete(f"Convert {dataset_name} to OpenAI format")

A single LLM call cannot solve this problem.

Approach 2: LLM Workflow

def normalize_dataset(dataset_name: str) -> list:
    dataset_url = web_search(f"{dataset_name} huggingface download url")
    raw_data = download(dataset_url)

    for attempt in range(3):
        code = llm.complete(f"Write code to convert to OpenAI format: {raw_data[:1000]}...")
        # ... validation and execution logic ...

    raise RuntimeError("Failed after 3 attempts")

You can add retries, but everything is hardcoded. The number of attempts, what to do on failure, when to give up. The LLM has no say in this. It just generates code when asked. All decisions are made by the developer at write time, not by the model at runtime.

Approach 3: Agent as a Function

system_prompt = """You are a data normalization agent.
Your goal is to download a HuggingFace dataset and convert it to OpenAI message format.

## Validation Rules
- Output must be valid JSON
- Each message must have 'role' and 'content' fields
- 'role' must be one of: 'system', 'user', 'assistant'
- All conversations must be properly structured

## Termination
- Call task_complete(result) when validation passes
- Call task_give_up(reason) if you've tried multiple approaches and none work
- Call task_impossible(reason) if the task is fundamentally impossible
"""

# BASE_TOOLS: capabilities to do the work
BASE_TOOLS = [
    web_search,       # search for dataset documentation
    read_file,        # read downloaded data
    write_file,       # write conversion code and output
    run_python,       # execute conversion code
]

# VALIDATION_TOOLS: verify the output
VALIDATION_TOOLS = [
    validate_json_schema,  # check OpenAI message format
    run_tests,             # run format validation tests
]

# TERMINAL_TOOLS: explicit task completion
TERMINAL_TOOLS = [
    task_complete,    # success with result
    task_give_up,     # tried but failed
    task_impossible,  # fundamentally can't be done
]

normalize_hf_to_openai = create_agent_function(
    name="normalize_hf_to_openai",
    system_prompt=system_prompt,
    tools=BASE_TOOLS + VALIDATION_TOOLS + TERMINAL_TOOLS,
    max_iterations=15
)

# Call it like any other function
result = normalize_hf_to_openai(dataset="squad_v2")

The agent searches for the dataset schema, writes conversion code, executes it, validates the output format, and if validation fails, it debugs and retries. It explicitly signals completion status via terminal tools.

The created Autonomous Function works like any other function within a system.

def build_training_dataset(sources: list[str]) -> Dataset:
    normalized = []

    for source in sources:
        # Autonomous Function: data normalization
        result = normalize_hf_to_openai(dataset=source)

        if result.status == "complete":
            normalized.extend(result.data)
        elif result.status == "impossible":
            log.warning(f"Skipping {source}: {result.reason}")

    # Autonomous Function: deduplication
    deduped = deduplicate_conversations(normalized)

    # Autonomous Function: quality filtering
    filtered = filter_low_quality(deduped, threshold=0.8)

    # Note: All three Autonomous Functions above can be combined into one
    return Dataset(filtered)

Each Autonomous Component explicitly signals success, failure, or impossibility. The caller handles each case appropriately.

The key shift is from procedure-driven to goal-driven functions. A traditional function answers “what steps should I execute?” That answer is fixed in its code. An Autonomous Function answers “what goal should I achieve?” It works out the steps at runtime.

When designing these, clarity of the goal definition matters most. Vague goals lead to vague outputs. Terminal tools let the agent signal completion explicitly. And boundaries like max iterations and timeouts provide safety rails.

This is a fundamental shift in how we think about computation. Instead of writing code that specifies every step, we define goals and let intelligent agents figure out the trajectory. The function becomes a container for intelligent problem-solving rather than a fixed sequence of operations.

A note on terminology: strictly speaking, every input-output mapping is a function. The “function” I mean here is the everyday one we write in code: a procedure whose steps are fixed when we write it.