Agent frameworks to learn for AI jobs: start with the concepts

What every framework is doing underneath

Strip away the abstractions and an agent is a loop:

1. 1Send the model the conversation plus descriptions of available tools.
2. 2The model replies either with an answer or with a request to call a tool with arguments.
3. 3Your code validates the request, runs the tool, and adds the result to the conversation.
4. 4Repeat until the model answers or a limit is reached.

Here is that loop in plain Python with a scripted stand-in for the model, so it runs without any API:

import json

def get_order_status(order_id: str) -> dict:
    orders = {"A101": "shipped", "A102": "processing"}
    if order_id not in orders:
        raise KeyError(f"unknown order {order_id}")
    return {"order_id": order_id, "status": orders[order_id]}

TOOLS = {"get_order_status": get_order_status}

# Scripted "model": first asks for a tool, then answers using the result.
def fake_model(messages):
    last = messages[-1]
    if last["role"] == "user":
        return {"tool": "get_order_status", "args": {"order_id": "A101"}}
    if last["role"] == "tool":
        status = json.loads(last["content"])["status"]
        return {"answer": f"Your order A101 is {status}."}

def run_agent(question, max_steps=4):
    messages = [{"role": "user", "content": question}]
    for step in range(max_steps):
        reply = fake_model(messages)
        if "answer" in reply:
            return reply["answer"], step + 1
        name, args = reply["tool"], reply["args"]
        if name not in TOOLS:                       # validate the request
            messages.append({"role": "tool", "content": json.dumps({"error": "no such tool"})})
            continue
        try:
            result = TOOLS[name](**args)
        except Exception as exc:                    # tool failure is data, not a crash
            result = {"error": str(exc)}
        messages.append({"role": "tool", "content": json.dumps(result)})
    return "Stopped: step limit reached.", max_steps

answer, steps = run_agent("Where is my order A101?")
print(answer, "| steps:", steps)
assert answer == "Your order A101 is shipped." and steps == 2

Everything a framework adds — typed tool definitions, memory, graphs of steps, tracing, parallel calls, handoffs between agents — is built around this loop. If you can write it, you can learn any framework quickly and debug it when its abstractions leak.

The concepts to learn, framework-independent

Reading job descriptions for framework signals

Instead of asking which framework is most popular, collect ten job descriptions for the role you want and tally what they name.

If no framework recurs, that is information too: the employer cares about concepts and will train you on their stack.

Choosing one to go deep in

Once your tally points somewhere, check a candidate framework against these questions using its official documentation:

1. 1Is it actively maintained, with recent releases and a changelog?
2. 2Does it support the language and cloud your target roles use?
3. 3Can you see and control the prompts and tool calls it sends, or does it hide them?
4. 4Does it support human approval, limits and tracing?
5. 5Is there a clear path from a prototype to something you can test?

A framework that fails question 3 makes debugging hard, which interviewers will probe.

Proving it on a resume

A line that says "LangGraph, CrewAI, AutoGen" says little. A line that says "built a read-only SQL agent with tool-argument validation, a 5-step limit and a 30-question evaluation set (26/30 correct)" says a lot, and it survives a change of framework. See three LLM portfolio pieces with acceptance criteria.

The Generative & Agentic AI add-on teaches agents from the loop upwards — tools, MCP, evaluation and guardrails — before relying on framework abstractions. For how much Python depth this needs, see Python depth for AI engineering.