Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Contextstrategieën voor agents

Les 14 van 20 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. De contextuitdaging voor agents
  2. Een geheugen met drie niveaus
  3. Tool-resultaten temmen
  4. Wanneer meerdere agents samenwerken
  5. Belangrijkste punten

De contextuitdaging voor agents

Een autonome agent koppelt tientallen API-aanroepen aan elkaar: deze redeneert, gebruikt tools, leest resultaten en iterereert. Bij elke stap groeit de context. Het verschil met een gewoon gesprek is dat deze groei niet van de gebruiker komt, maar van de agent zelf: een SQL-query die driehonderd rijen retourneert, een volledige opgehaalde webpagina of een volledig gelezen logbestand. Zonder beheerstrategie bereikt een agent binnen enkele iteraties de contextlimiet, vaak voordat de toegewezen taak is voltooid.

Het ontwerpen van een agent die zijn geheugen effectief beheert, komt daarom neer op het beantwoorden van drie vragen: wat moet intact blijven, wat kan worden samengevat en wat had nooit in de context mogen staan. We behandelen ze in die volgorde.

Een geheugen met drie niveaus

De structuur die we gebruiken, leunt op het klassieke onderscheid tussen werkgeheugen, episodisch geheugen en semantisch geheugen. Het werkgeheugen bevat de meest recente acties in hun ruwe vorm, omdat de agent deze exact zo nodig heeft om te beslissen wat er vervolgens moet gebeuren. Het episodisch geheugen bewaart samenvattingen van eerdere stappen: de agent weet dat hij een bepaald spoor heeft onderzocht en wat dat opleverde, zonder de details opnieuw te hoeven lezen. Tot slot accumuleert het semantisch geheugen feiten die eenmaal en voor altijd zijn vastgesteld—zoals de klant-ID, de versie van het databaseschema of de budgetbeperking—die nooit in een samenvatting verloren mogen gaan.

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)

Twee parameters verdienen bespreking voordat u ze klakkeloos overneemt. De afkapping op 2.000 tekens in add_action beschermt tegen uitgebreide tools, maar hakt er blindelings op los: als uw tools JSON retourneren, eindigt u met een ongeldig object midden in uw context. En max_episodes: 10 forceert een begrensde vergeetachtigheid—bij de elfde samenvatting verdwijnt de eerste. Voor een agent die lang draait, moet u belangrijke feiten naar facts promoveren voordat ze uit het episodische venster vallen, anders bent u ze permanent kwijt.

Tool-resultaten temmen

Tools leveren vaak omvangrijke resultaten op: webpagina’s, SQL-resultaten, bestandsinhoud. Dit is veruit de belangrijkste oorzaak van contextverzadiging voor een agent, en het is ook het makkelijkst op te lossen omdat u dit bij de inname regelt in plaats van achteraf.

De onderstaande functie biedt drie afkappingsstrategieën. De modus start past bij documenten waarvan de essentie bovenaan staat, zoals een artikel of rapport. De modus start_end werkt wanneer het einde de beslissende informatie bevat: een uitvoeringsspoor waarbij de fout als laatste verschijnt, een logbestand of een gepagineerd antwoord waarbij het totaal aan het einde staat. De modus summary kost een extra API-aanroep, wat alleen gerechtvaardigd is voor lange inhoud die echt nuttig is voor de rest van de redenering.

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]

Tabellarische resultaten vereisen een speciale aanpak. Een SQL-tabel halverwege afkappen verwijdert de koptekst of verstoort het gevoel van volume: de agent ziet twintig rijen en concludeert dat de tabel er slechts twintig bevat. Het onderstaande filter behoudt de koptekst, een steekproef van boven en onder, en—dit is het cruciale punt—vermeldt expliciet het aantal weggelaten rijen en het totaal. De agent weet dan dat hij naar een uittreksel kijkt en kan besluiten een aggregatiequery uit te voeren in plaats van op een steekproef te redeneren.

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"
    )

Wanneer meerdere agents samenwerken

Wanneer meerdere sub-agents parallel werken, is de verleiding groot om ze allemaal de volledige context te geven, voor de zekerheid. Dat is de beste manier om uw factuur te vermenigvuldigen met het aantal agents terwijl u hun prestaties verslechtert, omdat een rommelige context het model minder precies maakt in zijn eigen taak. Deel in plaats daarvan de minimale context: de globale doelstelling zodat de agent begrijpt waaraan hij bijdraagt, zijn eigen rol, gemeenschappelijke beperkingen en een begrensde uittreksel van resultaten die door zijn collega’s zijn geproduceerd.

@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()
            )
        )

De limiet van 200 tekens per gedeeltelijk resultaat weerspiegelt een intentie: een sub-agent moet weten wat anderen hebben gevonden, niet hoe ze dat hebben gedaan. Als uw agents de volledige details van naburige resultaten nodig hebben, moet u waarschijnlijk heroverwegen hoe u de rollen hebt verdeeld.

Belangrijkste punten

  • Structureer het agent-geheugen in drie niveaus: werkend, episodisch, semantisch
  • Compacteer automatisch wanneer het werkgeheugen de drempel overschrijdt
  • Kap tool-resultaten af voordat u ze in de context injecteert
  • Signaleer altijd dat een resultaat is afgekapt, en met hoeveel
  • Deel bij multi-agent-opstellingen alleen minimale context, gericht per rol