Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kontekststrategier for agenter

Lektion 14 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Kontekstudfordringen for agenter
  2. En hukommelse på tre niveauer
  3. At tæmme værktøjsresultater
  4. Når flere agenter arbejder sammen
  5. Vigtige pointer

Kontekstudfordringen for agenter

En autonom agent kæder snesevis af API-kald sammen: den ræsonnerer, bruger værktøjer, læser resultater og itererer. Ved hvert skridt vokser konteksten. Forskellen fra en almindelig samtale er, at denne vækst ikke kommer fra brugeren, men fra agenten selv: en SQL-forespørgsel, der returnerer tre hundrede rækker, en hel webside, der hentes, eller en komplet logfil, der læses. Uden en styringsstrategi rammer en agent kontekstgrænsen inden for få iterationer, ofte før den har afsluttet opgaven, du har tildelt den.

At designe en agent, der håndterer sin hukommelse effektivt, handler derfor om at besvare tre spørgsmål: hvad skal forblive intakt, hvad kan opsummeres, og hvad skulle aldrig have været i konteksten fra starten. Vi vil behandle dem i den rækkefølge.

En hukommelse på tre niveauer

Den struktur, vi bruger, trækker på den klassiske sondring mellem arbejdshukommelse, episodisk hukommelse og semantisk hukommelse. Arbejdshukommelsen indeholder de seneste handlinger i deres rå form, fordi agenten har brug for dem præcis, som de er, for at beslutte, hvad den skal gøre næste gang. Den episodiske hukommelse gemmer opsummeringer af tidligere trin: agenten ved, at den har udforsket et bestemt spor, og hvad det gav, uden at genlæse detaljerne. Endelig akkumulerer den semantiske hukommelse fakta, der er fastslået én gang for alle – kundens ID, versionsnummeret på databaseskemaet, budgetbegrænsningen – som aldrig må gå tabt i en opsummering.

from dataclasses import dataclass, field

@dataclass
class AgentMemory:
    """Three-level memory system for an agent."""

    # Level 1: working memory (current context)
    working: list[dict] = field(default_factory=list)

    # Level 2: episodic memory (summaries of past steps)
    episodes: list[str] = field(default_factory=list)

    # Level 3: semantic memory (permanent facts)
    facts: list[str] = field(default_factory=list)

    max_tokens_working: int = 20_000
    max_episodes: int = 10

    def add_action(self, action: str, result: str):
        """Adds an action to working memory."""
        self.working.append({
            "action": action,
            "result": result[:2000],  # Truncate long results
        })
        self._check_compaction()

    def add_fact(self, fact: str):
        """Adds a permanent fact."""
        if fact not in self.facts:
            self.facts.append(fact)

    def _check_compaction(self):
        tokens = sum(
            len(str(e)) // 4 for e in self.working
        )
        if tokens > self.max_tokens_working:
            self._compact()

    def _compact(self):
        """Compacts working memory into an episode."""
        import openai
        client = openai.OpenAI()

        text = "\n".join(
            f"Action: {a['action']}\nResult: {a['result']}"
            for a in self.working[:-2]
        )

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                "Summarize these agent actions in 3-5 key points. "
                "Keep important facts, results, and decisions.\n\n"
                f"{text}"
            ),
            max_output_tokens=300,
        )

        self.episodes.append(response.output_text)
        self.working = self.working[-2:]  # Keep the last 2 actions

        # Limit the number of episodes
        if len(self.episodes) > self.max_episodes:
            self.episodes = self.episodes[-self.max_episodes:]

    def build_context(self) -> str:
        """Builds the full context for the next call."""
        parts = []

        if self.facts:
            parts.append(
                "Established facts:\n" + "\n".join(f"- {f}" for f in self.facts)
            )

        if self.episodes:
            parts.append(
                "Summarized history:\n" + "\n---\n".join(self.episodes)
            )

        if self.working:
            parts.append(
                "Recent actions:\n" + "\n".join(
                    f"- {a['action']} → {a['result'][:500]}"
                    for a in self.working
                )
            )

        return "\n\n".join(parts)

To parametre fortjener en diskussion, før du kopierer dem blindt. Trunkeringen på 2.000 tegn i add_action beskytter mod snaksomme værktøjer, men den skærer blindt: hvis dine værktøjer returnerer JSON, ender du med et ugyldigt objekt midt i din kontekst. Og max_episodes: 10 håndhæver en begrænset glemsomhed – ved den ellevte opsummering forsvinder den første. For en agent, der kører i lang tid, bør du forflytte vigtige fakta til facts, før de falder ud af det episodiske vindue, ellers mister du dem permanent.

At tæmme værktøjsresultater

Værktøjer returnerer ofte voluminøse resultater: websider, SQL-resultater, filindhold. Dette er langt den hyppigste årsag til kontekstmætning for en agent, og det er også det letteste at fixe, fordi du håndterer det ved indlæsning snarere end efterfølgende.

Funktionen nedenfor tilbyder tre trunkeringsstrategier. Tilstanden start passer til dokumenter, hvor det væsentlige står øverst, som en artikel eller rapport. Tilstanden start_end virker, når slutningen bærer den afgørende information: et eksekveringsspor, hvor fejlen vises sidst, en logfil eller et pagineret svar, hvor totalen står til sidst. Tilstanden summary koster et ekstra API-kald, hvilket kun er berettiget for langt indhold, der er virkelig nyttigt for resten af ræsonnementet.

def truncate_tool_result(
    result: str,
    max_tokens: int = 2000,
    strategy: str = "start_end",
) -> str:
    """Truncates a tool result while preserving key information."""
    estimated_tokens = len(result) // 4

    if estimated_tokens <= max_tokens:
        return result

    max_chars = max_tokens * 4

    match strategy:
        case "start":
            return result[:max_chars] + "\n[... truncated]"

        case "start_end":
            half = max_chars // 2
            return (
                result[:half]
                + "\n[... middle truncated ...]\n"
                + result[-half:]
            )

        case "summary":
            import openai
            client = openai.OpenAI()
            response = client.responses.create(
                model="gpt-5.6-terra",
                input=f"Summarize this data keeping the essentials:\n{result}",
                max_output_tokens=max_tokens,
            )
            return response.output_text

    return result[:max_chars]

Tabellariske resultater kræver særlig håndtering. At klippe en SQL-tabel midt over fjerner overskriften eller fordrejer fornemmelsen af volumen: agenten ser tyve rækker og konkluderer, at tabellen kun indeholder tyve. Filteret nedenfor beholder overskriften, en prøve fra toppen og bunden, og – dette er pointen – angiver eksplicit antallet af udeladte rækker og totalen. Agenten ved derefter, at den kigger på et uddrag, og kan beslutte at køre en aggregatforespørgsel i stedet for at ræsonnere ud fra en prøve.

def filter_sql_result(result: str, question: str) -> str:
    """Filters a SQL result to keep only what's relevant."""
    lines = result.strip().split("\n")

    if len(lines) <= 20:
        return result

    # Keep the header and first/last lines
    header = lines[0]
    first_lines = lines[1:6]
    last_lines = lines[-5:]

    return (
        f"{header}\n"
        + "\n".join(first_lines)
        + f"\n[... {len(lines) - 11} lines omitted ...]\n"
        + "\n".join(last_lines)
        + f"\n\nTotal: {len(lines) - 1} rows"
    )

Når flere agenter arbejder sammen

Når flere underagenter arbejder parallelt, er fristelsen stor til at give dem alle den fulde kontekst, bare for en sikkerheds skyld. Det er den bedste måde at gange din regning med antallet af agenter på, samtidig med at du forringer deres ydeevne, da en rodet kontekst gør modellen mindre præcis i sin egen opgave. Del i stedet den minimale kontekst: det globale mål, så agenten forstår, hvad den bidrager til, dens egen rolle, fælles begrænsninger og et begrænset uddrag af resultater produceret af dens kolleger.

@dataclass
class SharedContext:
    """Context shared between sub-agents."""
    objective: str
    constraints: list[str]
    partial_results: dict[str, str] = field(default_factory=dict)

    def context_for_sub_agent(self, role: str) -> str:
        """Generates a targeted context for a sub-agent."""
        return (
            f"Global objective: {self.objective}\n"
            f"Your role: {role}\n"
            f"Constraints: {', '.join(self.constraints)}\n"
            f"Results from other agents:\n"
            + "\n".join(
                f"- {k}: {v[:200]}"
                for k, v in self.partial_results.items()
            )
        )

Grænsen på 200 tegn pr. delresultat afspejler en hensigt: en underagent behøver at vide, hvad andre har fundet, ikke hvordan de fandt det. Hvis dine agenter har brug for alle detaljer fra naboresultater, bør du sandsynligvis genoverveje, hvordan du har fordelt rollerne.

Vigtige pointer

  • Strukturér agentens hukommelse i tre niveauer: arbejdende, episodisk, semantisk
  • Kompaktér automatisk, når arbejdshukommelsen overskrider tærsklen
  • Trunkér værktøjsresultater, før de injiceres i konteksten
  • Signalér altid, at et resultat er trunkeret, og i hvilket omfang
  • Ved multi-agent opsætninger: del minimal kontekst målrettet efter rolle