Nexar Academy — 1-1 Mentorskap

Vad du ska ha när du är klar

Du kommer ha byggt din första AI-agent — en som kan räkna matte åt dig genom att anropa dina egna funktioner i en loop. Det är 30 rader Python. När du ser det köra förstår du exakt vad en agent är, och du har grunden för att bygga vad som helst ovanpå.

Inga förkunskaper i AI krävs. Du bör ha sett Python-kod förut. Om inte — oroa dig inte, vi förklarar varje rad.

Först: vad ÄR en agent? (1 minut)

En chatbot är en LLM som svarar dig en gång. En agent är en LLM som löser problem genom att använda verktyg i en loop.

Simon Willison (som myntade den här definitionen som nu är kanonisk) säger det så här:

"An LLM agent runs tools in a loop to achieve a goal."

Exempel på skillnaden:

Du frågar ChatGPT: "Vad är vädret i Stockholm just nu?"

Chatbot-svar: "Jag har ingen tillgång till realtidsdata. Du kan kolla SMHI."
Agent-svar: "14 grader, molnigt." (Agenten insåg att den behövde ett verktyg, anropade en väder-API, fick resultatet, svarade.)

Samma LLM. Skillnaden är att agenten har verktyg (funktioner den får anropa) och en loop (den fortsätter tills jobbet är gjort).

Chatbot vs Agent

Det magiska 3-stegs-mönstret

Varje agent-system — Claude Code, Cursor, din banks chatbot, självkörande Teslas planeringssystem — använder samma loop:

Användaren ger ett mål ("Räkna ut 23 × 47 + 119")
LLM:en bestämmer om den behöver verktyg eller kan svara direkt
Om verktyg: kör verktyget, ge resultatet tillbaka till LLM:en, loopa

Tills LLM:en säger "klar, här är svaret".

Agent-loopen

Det är hela konceptet. Inget mer. När du fattar det här har du fattat 80% av modern AI-engineering.

Vad vi ska bygga

En kalkylator-agent. Du säger: "Räkna ut 23 × 47 + 119". Den:

Inser att den inte kan räkna säkert själv (LLMs är dåliga på aritmetik — fact)
Anropar din multiply(23, 47) → får 1081 tillbaka
Anropar din add(1081, 119) → får 1200 tillbaka
Svarar: "1200"

Varför kalkylator och inte väder?

Ingen extern API behövs (0 setup)
Du ser loopen köra 2 gånger i samma svar — poängen blir tydlig
Körs 100% lokalt, du kan debugga

Vad du behöver

En dator (Mac, Windows, Linux — alla funkar)
Python 3.10 eller senare. Kolla med python --version i terminalen
Ett Anthropic-konto med minst $5 i API-credits — console.anthropic.com/settings/billing

Ingen tidigare AI-erfarenhet behövs. Om du aldrig kört Python — följ stegen exakt.

Steg 1: Skaffa API-nyckel

Logga in på console.anthropic.com. Klicka API Keys i vänstermenyn → Create Key.

Ge den ett namn ("test-agent" funkar). Kopiera den långa strängen som börjar med sk-ant-....

VIKTIGT: Den här strängen visas bara EN gång. Spara den säkert (t.ex. i en textfil eller en password manager). Om du tappar bort den måste du skapa en ny.

Anthropic API Keys-sida

Steg 2: Sätt upp projektet

Öppna terminalen. Skapa en ny mapp och gå in i den:

mkdir first-agent
cd first-agent

Skapa en Python-miljö (håller paket isolerade):

python -m venv venv

Aktivera den:

Mac/Linux: source venv/bin/activate
Windows (cmd): venv\Scripts\activate
Windows (PowerShell): venv\Scripts\Activate.ps1

Du ser (venv) framför din prompt nu — det betyder att miljön är aktiv.

Installera Anthropics SDK:

pip install anthropic

Sätt din API-nyckel som miljövariabel:

Mac/Linux: export ANTHROPIC_API_KEY="sk-ant-din-nyckel-här"
Windows (cmd): set ANTHROPIC_API_KEY=sk-ant-din-nyckel-här
Windows (PowerShell): $env:ANTHROPIC_API_KEY="sk-ant-din-nyckel-här"

(Obs: denna env-var försvinner när du stänger terminalen. För permanent: lägg till i din .bashrc/.zshrc eller Windows env-variables. Senare problem.)

Steg 3: Skriv agenten

Skapa en fil agent.py i mappen. Klistra in denna kod:

import anthropic
import json

client = anthropic.Anthropic()

# 1. DEFINIERA VERKTYGEN
# Detta är "kontraktet" LLM:en ser — namn + beskrivning + schema
tools = [
    {
        "name": "multiply",
        "description": "Multiplicerar två tal och returnerar resultatet.",
        "input_schema": {
            "type": "object",
            "properties": {
                "a": {"type": "number", "description": "Första talet"},
                "b": {"type": "number", "description": "Andra talet"},
            },
            "required": ["a", "b"],
        },
    },
    {
        "name": "add",
        "description": "Adderar två tal och returnerar resultatet.",
        "input_schema": {
            "type": "object",
            "properties": {
                "a": {"type": "number"},
                "b": {"type": "number"},
            },
            "required": ["a", "b"],
        },
    },
]

# 2. IMPLEMENTERA VERKTYGEN
# Den riktiga koden som körs när LLM:en "anropar" verktyget
def run_tool(name, inputs):
    if name == "multiply":
        return inputs["a"] * inputs["b"]
    if name == "add":
        return inputs["a"] + inputs["b"]
    return "Okänt verktyg"

# 3. AGENT-LOOPEN
def run_agent(user_message):
    messages = [{"role": "user", "content": user_message}]

    for iteration in range(10):  # safety-cap på 10 iterationer
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=tools,
            messages=messages,
        )

        # Klar? Returnera svaret
        if response.stop_reason == "end_turn":
            for block in response.content:
                if block.type == "text":
                    return block.text

        # Vill använda verktyg?
        if response.stop_reason == "tool_use":
            for block in response.content:
                if block.type == "tool_use":
                    print(f"🔧 Agenten anropar {block.name}({block.input})")
                    result = run_tool(block.name, block.input)
                    print(f"📦 Resultat: {result}")

                    messages.append({"role": "assistant", "content": response.content})
                    messages.append({
                        "role": "user",
                        "content": [{
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": str(result),
                        }],
                    })

# 4. KÖR
if __name__ == "__main__":
    answer = run_agent("Räkna ut 23 * 47 + 119. Visa arbetsgången.")
    print("\n🤖 Agenten säger:", answer)

Steg 4: Kör den

python agent.py

Du ska se något i stil med:

🔧 Agenten anropar multiply({'a': 23, 'b': 47})
📦 Resultat: 1081
🔧 Agenten anropar add({'a': 1081, 'b': 119})
📦 Resultat: 1200

🤖 Agenten säger: 23 * 47 = 1081, och 1081 + 119 = 1200. Svaret är 1200.

Läs det där noga. Agenten:

Fick frågan
Insåg att den behövde multiply först
Anropade ditt verktyg
Fick resultatet
Insåg nu att den behövde add
Anropade ditt andra verktyg
Fick resultatet
Sammanfattade svaret

Det är agent-loopen i sin renaste form.

Terminal-output från agent-loopen

Saker som kan gå fel (vanliga 2026)

ModuleNotFoundError: No module named 'anthropic' Du har inte aktiverat venv, eller kör fel Python. Kolla att (venv) visas i prompten. Kör which python (Mac/Linux) eller where python (Windows) — ska peka på venv/-mappen.

AuthenticationError: Invalid API key Tre vanliga orsaker:

Du klistrade in med osynliga radbrytningar. Kör echo $ANTHROPIC_API_KEY — se att den är en rad. Sätt om ifall inte.
Du har sk-ant-... med extra blanksteg i början/slutet. Citat: "Most reported bug in Cursor forum. Users kopierar med trailing whitespace."
Nyckeln är raderad i console. Skapa ny.

tools.X.custom.input_schema: JSON schema is invalid Du har nog fått med anyOf eller const i schemat. Anthropics tool-validator är strikt — håll dig till type, properties, required. Inget fancy.

Agenten loopar för evigt Har hänt vid buggiga verktyg som returnerar fel som förvirrar LLM:en. Därför har vi for iteration in range(10) — det är safety-capen. Om du ser loopen gå till 10 → läs output, se vad som går fel i verktyget.

RateLimitError Första gången i Anthropic-API = låg rate limit ($5 credits = ca 20 requests/min). Vänta en minut och kör igen. Höjer sig automatiskt efter några dagars användning.

Wow-momentet

Byt ut user_message på sista raden mot:

answer = run_agent("Jag har 3 barn. Mellanbarnets ålder är 7. Storebror är 3 år äldre, lillasyster är halva mellanbarnets ålder. Hur gamla är alla?")

Kör igen. Se hur agenten anropar multiply och add i helt andra kombinationer, resonerar kring uppgiften, landar i svaret. Du lärde den inget nytt — verktygen är samma. Den orchestrerar dem själv.

Det är poängen. Verktygen är "vad den kan göra". LLM:en är "hur den tänker". Agenten är loopen som gifter ihop dem.

Det här ÄR allt avancerade agenter också

Claude Code, Cursor, ChatGPT Operator, Devin — allt du har hört talas om — är samma loop med:

Fler verktyg (läs_fil, skriv_fil, kör_kommando, google-sök, skicka_email...)
Längre loopar (hundratals iterationer)
Snyggare UI (terminal, editor, browser)
Bättre prompting ("du är en expert på...")
Memory/RAG för att hantera långa sammanhang

Men kärnan är det du precis byggde. 30 rader Python.

Vanliga missuppfattningar att slänga

"Det här är AGI." Nej. En agent är konditionell automation. Den sätter inte egna mål, den utför målen du ger.

"Jag måste lära mig LangChain/CrewAI/AutoGen först." Nej. Anthropic själva rekommenderar (i "Building Effective Agents"): "Start with simple prompts... add frameworks only when simpler solutions fall short." Du har precis startat rätt.

"Jag behöver MCP för att göra nåt användbart." MCP (Model Context Protocol) är ett transportlager för att paketera verktyg som delbara servers. Du behöver det inte för att bygga agenter. Det löser ett skalningsproblem, inte ett grundproblem.

"Jag behöver finetuning." Nej. Prompt + verktygsschema räcker för 99% av use cases. Finetuning är reserverat för specialfall.

Vad du gör nu

Lägg till ett tredje verktyg — t.ex. subtract eller divide. Se att loopen funkar oförändrad.
Byt ut kalkylatorn mot ett riktigt verktyg — t.ex. get_weather(city) som fetch:ar open-meteo.com (gratis, ingen auth). Nu är agenten kopplad till internet.
Läs Anthropics "Building Effective Agents" — kompletterar med mönster (prompt chaining, routing, parallelization) som alla bygger ovanpå det du just lärt dig.

Nästa lektion i spåret: En agent som faktiskt är användbar — läs-mitt-email + skriv-draft-svar.

Referenser värda att läsa

Simon Willison — "Agents are models using tools in a loop" — den kanoniska definitionen
Anthropic — "Building Effective Agents" — officiella forskningen
sketch.dev — "The Unreasonable Effectiveness of an LLM Agent Loop" — hela agenten i under 30 rader
Anthropic docs — Tool use overview — officiella tekniska dokumentationen

Bygg din första agent med tool-use