Kontekstistrategiat agenteille
Tällä sivulla
Kontekstihaaste agenteille
Autonominen agentti ketjuttaa yhteen kymmeniä API-kutsuja: se päättelyä, käyttää työkaluja, lukee tuloksia ja toistaa prosessia. Jokaisella askeleella konteksti kasvaa. Ero tavalliseen keskusteluun on siinä, että tämä kasvu ei johdu käyttäjästä vaan agentista itsestään: SQL-kysely palauttaa kolmesataa riviä, koko verkkosivu haetaan tai kokonainen lokitiedosto luetaan. Ilman hallintastrategiaa agentti saavuttaa kontekstirajan muutaman iteraation kuluessa, usein ennen kuin se on suorittanut sille antamasi tehtävän loppuun.
Agentin suunnittelu, joka hallitsee muistiaan tehokkaasti, tiivistyy siis kolmeen kysymykseen: mitä täytyy pitää ehjänä, mitä voidaan tiivistää ja mitä ei olisi pitänyt päästää kontekstiin lainkaan. Käsittelemme niitä tässä järjestyksessä.
Kolmitasoinen muisti
Käyttämämme rakenne perustuu klassiseen erotteluun työmuistin, episodisen muistin ja semanttisen muistin välillä. Työmuisti pitää yllä viimeisimpiä toimintoja raakamuodossa, koska agentti tarvitsee niitä juuri sellaisinaan päättääkseen seuraavasta askeleesta. Episodinen muisti säilyttää yhteenvedot menneistä vaiheista: agentti tietää tutkineensa tiettyä johtolankaa ja mitä siitä seurasi, ilman että sen tarvitsee lukea yksityiskohtia uudelleen. Lopuksi semanttinen muisti kerää kerran lopullisesti vahvistetut faktat – asiakastunnus, tietokantaskaeman versio, budjettirajoite – jotka eivät saa koskaan kadota tiivistelmään.
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)
Kaksi parametria ansaitsee keskustelua ennen kuin kopioit ne sellaisinaan. 2 000 merkin katkaisu kohdassa add_action suojaa puheliasilta työkaluilta, mutta se leikkaa sokeasti: jos työkalusi palauttavat JSON-muotoista dataa, päädyt kontekstiisi keskelle virheelliseen objektiin. Ja max_episodes: 10 pakottaa rajatun unohtamisen: yhdennentoista yhteenvedon kohdalla ensimmäinen katoaa. Jos agentti toimii pitkään, siirrä tärkeät faktat kohtaan facts ennen kuin ne putoavat episodisen ikkunan ulkopuolelle, muuten menetät ne pysyvästi.
Työkalutulosten kesyttäminen
Työkalut palauttavat usein massiivisia tuloksia: verkkosivuja, SQL-tuloksia, tiedostojen sisältöä. Tämä on ylivoimaisesti yleisin syy agentin kontekstin kyllästymiseen, ja se on myös helpoin korjata, koska hoidat sen jo datan vastaanottovaiheessa etkä jälkikäteen.
Alla oleva funktio tarjoaa kolme katkaisustrategiaa. Tila start sopii dokumentteihin, joissa oleelliset asiat ovat alussa, kuten artikkelit tai raportit. Tila start_end toimii, kun lopussa on ratkaiseva tieto: suoritusjälki, jossa virhe ilmestyy viimeisenä, lokitiedosto tai sivutettu vastaus, jossa kokonaismäärä on lopussa. Tila summary maksaa ylimääräisen API-kutsun, mikä on perusteltua vain pitkälle sisällölle, joka on todella hyödyllistä jäljellä olevalle päättelylle.
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]
Taulukkomuotoiset tulokset vaativat erityiskohtelua. SQL-taulun katkaiseminen keskeltä poistaa otsikon tai vääristää käsitystä volyymista: agentti näkee kaksikymmentä riviä ja päättelee taulun sisältävän vain kaksikymmentä riviä. Alla oleva suodatin säilyttää otsikon, otoksen alusta ja lopusta sekä – ja tämä on avainasia – ilmoittaa nimenomaisesti pois jätettyjen rivien määrän ja kokonaismäärän. Agentti tietää tällöin katsovansa otosta ja voi päättää suorittaa aggregointikyselyn sen sijaan, että se päättelisi otoksen perusteella.
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"
)
Kun useat agentit työskentelevät yhdessä
Kun useat alagentit työskentelevät rinnakkain, kiusaus on antaa niille kaikille koko konteksti varmuuden vuoksi. Se on paras tapa kertoa laskusi agenttien lukumäärällä ja samalla heikentää niiden suorituskykyä, sillä sekainen konteksti tekee mallista epätarkemman omassa tehtävässään. Sen sijaan jaa minimaalinen konteksti: globaali tavoite, jotta agentti ymmärtää mihin se contriboi, sen oma rooli, yhteiset rajoitteet ja rajattu otos muiden tuottamista tuloksista.
@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()
)
)
200 merkin raja osittaisille tuloksille heijastaa tarkoitusta: alagentin tarvitsee tietää, mitä muut löysivät, ei sitä, miten ne sen löysivät. Jos agenttisi tarvitsevat naapuritulosten kaikki yksityiskohdat, sinun tulee todennäköisesti harkita roolien jakoa uudelleen.
Keskeiset asiat
- Jäsennä agentin muisti kolmelle tasolle: työmuisti, episodinen muisti, semanttinen muisti
- Tiivistä automaattisesti, kun työmuisti ylittää kynnyksen
- Katkaise työkalujen tulokset ennen niiden syöttämistä kontekstiin
- Ilmoita aina, että tulos on katkaistu ja kuinka paljon
- Moniagenttijärjestelmissä jaa vain roolikohtainen minimaalinen konteksti