PricingLoginStart free
Claude Architect · leksjon

Når bør De bruke en agent

Agenter kontra enkle prompter kontra faste pipelines.

Leksjon 3 av 413 trinn

Når bør De bruke en agent er en gratis leksjon i Claude Architect på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Claude Architect, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Claude Architect inneholder totalt 4 leksjoner.

Tre måter å løse en oppgave på

Før du bygger noe med Claude, må du ta én viktig beslutning: Hvor mye autonomi trenger oppgaven? Det finnes tre mønstre:

  • Enkel prompt — én forespørsel, ett svar.
  • Fast pipeline — en kjent sekvens med trinn som du setter sammen selv.
  • Agent — modellen bestemmer hvilke verktøy som skal kalles og når, og gjentar prosessen til arbeidet er ferdig.

Å velge riktig mønster er en arkitekturbeslutning. Bygger du for mye, får du flere kostnader og feilkilder; bygger du for lite, kan oppgaven ikke fullføres. Denne leksjonen lærer deg å velge riktig.

Den enkle prompten

En enkel prompt er ett API-kall: Du sender en system-melding sammen med messages, og får ett svar tilbake. Ingen verktøy, ingen løkke.

Bruk den når oppgaven er selvstendig: skrive om tekst, oppsummere et avsnitt, klassifisere en setning eller svare på et spørsmål ut fra oppgitt kontekst. Hvis alt modellen trenger allerede finnes i prompten, trenger du ikke noe mer.

Husk: Modellen beholder ingen tilstand. Hvert kall er uavhengig — du må selv sende hele historikken i messages på nytt hvis du vil bevare kontinuiteten.

import anthropic

client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=512,
    system="You rewrite text to be clear and concise.",
    messages=[
        {"role": "user", "content": "Rewrite: 'The meeting, which was long, ended.'"}
    ],
)
print(resp.content[0].text)

Den faste pipelinen

En fast pipeline kobler sammen flere trinn i en kjent rekkefølge. Du — arkitekten — bestemmer sekvensen i koden. Trinn 1 leverer til trinn 2, som leverer til trinn 3.

Dette kalles også prompt chaining. Bruk det når trinnene er kjente og sekvensielle: hent ut felter, valider dem og formater deretter en rapport. Modellen velger aldri fremgangsmåten — det gjorde du på forhånd.

Pipelines er forutsigbare og enkle å feilsøke fordi kontrollflyten er fast. Ulempen er manglende fleksibilitet: De kan ikke tilpasse seg når en oppgave krever ulike trinn avhengig av hva de finner.

# Fixed pipeline: each step's output feeds the next
extracted = extract_fields(document)        # step 1
validated = validate(extracted)             # step 2
report    = format_report(validated)        # step 3
# The sequence is hard-coded. The model never picks the path.

Agenten

En agent overlater kontrollflyten til modellen. Du gir Claude et mål og et sett med tools, og modellen bestemmer hvilket verktøy som skal kalles, undersøker resultatet og bestemmer hva som skal gjøres videre — i en løkke til målet er nådd.

Det viktigste kjennetegnet er at beslutningene er modellstyrte, ikke hardkodet. Du vet ikke på forhånd hvor mange trinn den vil ta, eller hvilke verktøy den vil bruke.

Bruk en agent når veien er åpen: undersøke en feil, forske på et tema på tvers av kilder eller løse en kundehenvendelse som kan kreve oppslag, refusjon eller eskalering, avhengig av hva som blir funnet.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a support agent. Resolve the customer's issue.",
    tools=[get_customer, lookup_order, process_refund, escalate_to_human],
    messages=conversation,
)
# The model chooses which tool(s) to call based on the situation.

Agentløkken

En agent kjører en løkke som styres av svarets stop_reason:

  • Send forespørselen.
  • Undersøk stop_reason.
  • Hvis den er tool_use, kjør de forespurte verktøyene, legg resultatene til i meldingshistorikken og send på nytt.
  • Gjenta til stop_reason er end_turn.

Du avslutter på stoppårsaken — API-ets eget signal om at turen er fullført. Dette er kjernen i enhver agent.

while True:
    resp = client.messages.create(model=MODEL, max_tokens=1024,
                                  system=SYSTEM, tools=TOOLS,
                                  messages=messages)
    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason == "end_turn":
        break                       # task complete
    if resp.stop_reason == "tool_use":
        results = run_tools(resp.content)
        messages.append({"role": "user", "content": results})

Analyser aldri tekst for «ferdig»

En vanlig og farlig feil er å avslutte løkken ved å lete gjennom modellens svar etter ord som "done" eller "finished". Modellen kan si "done" midt i en tanke, eller aldri si det i det hele tatt. Dette er et klassisk anti-mønster.

Avslutt alltid ved stop_reason — end_turn betyr at prosessen er fullført. Stoppårsaken er et strukturert og pålitelig signal; fritekst er det ikke.

Iterasjonsgrenser (et maksimalt antall løkkerunder) er et sikkerhetsnett som hindrer løkker i å løpe løpsk — aldri den primære stoppmekanismen. Den egentlige stoppen er alltid stoppårsaken.

# ANTI-PATTERN: do not do this
if "done" in resp.content[0].text.lower():
    break

# CORRECT: rely on the structured stop reason
if resp.stop_reason == "end_turn":
    break

Beslutningsregel: Er veien kjent?

Her er det ene spørsmålet som avgjør agent eller pipeline:

Kjenner du trinnene på forhånd?

  • Ja, faste og sekvensielle → bruk en fast pipeline (prompt chaining). Den er billigere, raskere og enklere å feilsøke.
  • Nei, åpen undersøkelse → bruk en agent med adaptiv dekomponering.

Hvis en oppgave ikke trenger eksterne data eller handlinger og får plass i ett kall, trenger du ikke engang en pipeline — en enkel prompt er nok. Velg alltid det enkleste mønsteret som løser oppgaven.

Beslutninger kontra garantier

Agenter er kraftige fordi modellen bestemmer — men modellens beslutninger er probabilistiske (omtrent 90 % pålitelige), ikke sikre. Derfor gjelder en annen regel:

La modellen bestemme; reserver hardkodet logikk for garantier.

Når en feil handling får økonomiske, juridiske eller sikkerhetsmessige konsekvenser — for eksempel en stor refusjon — stoler du ikke på en prompt. Du håndhever regelen deterministisk med en hook eller en programmert forhåndsbetingelse. Prompter veileder; hooks garanterer.

En agent er altså riktig struktur, samtidig som kritiske regler fortsatt håndheves i koden rundt den. De to tingene er ikke i konflikt.

# Prompt guidance is ~90% reliable — fine for routine routing.
# A hook is 100% deterministic — use it for critical rules:
#   block process_refund when amount > 500
#   block process_refund until get_customer returns a verified ID
# Outgoing-call hooks reject policy-violating actions before they run.

Når en pipeline slår en agent

Ikke velg en agent bare fordi det føles moderne. En fast pipeline er best når:

  • Rekkefølgen på trinnene er kjent og stabil.
  • Du ønsker forutsigbare kostnader og svartider (ingen åpne løkker).
  • Du trenger en kontrollflyt som er enkel å teste og feilsøke.

Eksempel: Strukturert datauttrekking der du alltid henter ut data, validerer dem og deretter formaterer dem. Veien endres aldri, så det er riktig og robust å hardkode den. Å legge til autonomi fra en agent her gir bare mer ikke-determinisme og høyere kostnader uten noen fordel.

Når en agent er det riktige valget

Velg en agent når arbeidet virkelig er åpent, og veien avhenger av det som oppdages underveis:

  • Feilundersøking — finn inngangspunkter med grep, les filer og følg bruksområder; du kan ikke skripte ruten på forhånd.
  • Forskning på tvers av flere kilder — en koordinator dekomponerer spørsmålet og delegerer til underagenter.
  • Kundestøtte — én sak trenger et oppslag, en annen en refusjon og en tredje en eskalering.

I alle disse tilfellene avhenger neste trinn av det forrige resultatet. Nettopp denne avhengigheten håndterer en agentløkke, mens en fast pipeline ikke kan håndtere den.

system=("You are a debugging agent. Investigate the failing test "
        "and find the root cause.")
tools=[glob_tool, grep_tool, read_tool, bash_tool]
# The model adapts: Grep entry points -> Read files -> Grep usages
# -> Read consumers. The route is decided at runtime, not by you.

En praktisk sjekkliste

Gå gjennom denne korte sjekklisten for alle nye oppgaver:

  • Én selvstendig forespørsel? → enkel prompt.
  • Kjent, fast sekvens med trinn? → fast pipeline.
  • Åpen oppgave der veien avhenger av resultatene? → agent.
  • Kritisk regel (penger / juss / sikkerhet)? → håndhev den med en hook, uansett hvilket mønster du valgte.

Velg som standard det enkleste mønsteret som fungerer. Legg bare til autonomi når oppgaven faktisk trenger det — og legg til deterministisk håndheving overalt der en feil ville vært kostbar. Denne balansen skiller en arkitekt fra en som bare prøver seg frem.

Kort kontroll

Test beslutningsevnen din på et realistisk scenario.

Besvar den i den interaktive leksjonen

Oppsummering: Velg mønster

Viktigste poenger:

  • Enkel forespørsel — selvstendig, ett kall, ingen tilstand (send hele historikken på nytt selv).
  • Fast pipeline — kjente, sekvensielle trinn; forutsigbar, billig og enkel å feilsøke.
  • Agent — en åpen arbeidsflyt der modellen bestemmer under kjøring via agentløkken.
  • Løkken avsluttes når stop_reason == end_turn, aldri ved å analysere tekst; grense for antall iterasjoner er bare et sikkerhetsnett.
  • Modellens avgjørelser er sannsynlighetsbaserte; håndhev kritiske regler for økonomi, juss og sikkerhet med hooks eller programmatiske forhåndsbetingelser for deterministiske garantier.
  • Ta som utgangspunkt det enkleste mønsteret som løser oppgaven.

Behersk dette valget, så kan resten av agentarkitekturen bygges ryddig oppå det.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
26
Leksjoner
104
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Når bør De bruke en agent» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Claude Architect, inkludert «Når bør De bruke en agent», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Claude Architect inneholder totalt 4 leksjoner.

Hva lærer jeg i «Når bør De bruke en agent»?

Agenter kontra enkle prompter kontra faste pipelines. Du øver på Claude Architect med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Claude Architect?

Ingen tidligere erfaring er nødvendig. Claude Architect på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Når bør De bruke en agent»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Claude Architect-leksjonen?

Ja. Alle Claude Architect-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Hva som gjør et system agentisk
  2. Modellstyrte kontra hardkodede beslutninger
  3. Når bør De bruke en agent
  4. Oversikt over den agentiske løkken
← Tilbake til Claude Architect