Adaptation Paradigms

Adaptive AI agents can be improved in three different ways:

1. Behaviour adaptation (token space)
2. Knowledge adaptation (token space)
3. Model adaptation (weight space)

Behaviour adaptation lives in procedural memory. -> Skills

This is for repeated execution mistakes:

• wrong interpreter paths
• missing imports
• the same workflow error showing up in every fresh session

The fix is trajectory-to-skill learning.

Every run produces a trace:

• files inspected
• tool calls made
• errors encountered
• fixes that worked

An off-path LLM then reviews those traces under a strict induction contract and turns them into a structured skill file.

That skill is reviewed by a human before it becomes active.

Approved skills move into a version-controlled skill box, where they can be retrieved into context on later runs.

The point is simple:

stop rediscovering the same operational fix.

Knowledge adaptation lives in semantic memory. -> Graph RAG

This is for codebases where the bottleneck is not generation.
It is retrieval.

Keyword search and regex are too shallow for large repositories because they miss relationships.

A knowledge graph solves that by:

• extracting entities (nodes)
• defining typed relationships (edges)

Then retrieval works like this:

• prune duplicates
• find an anchor node with semantic similarity
• traverse the graph with PageRank-style scoring
• inject the best file hints into the prompt
• keep ingesting new commits without rebuilding everything

This is the layer that helps an agent find the right part of the knowledge base faster, with fewer tool calls and less wasted context.

Model adaptation is different. -> Fine-tuning

This is for the model weights themselves.

You use it when token-space adaptation (the previous two methods) has been exhausted and the behaviour still will not change.

Typical use cases include:

• strict refusals for sensitive topics
• specific persona or tone patches
• output format control

The most common technique here is LoRA.

Instead of retraining the whole model, you freeze the base weights and train a small low-rank add-on.

That keeps the change narrow and helps avoid catastrophic forgetting.

Quantisation can reduce the memory footprint further.

And routers can decide which specialised adapter to load based on the incoming query.

So the decision rule is:

• if the agent keeps repeating the same workflow mistake, adapt behaviour
• if the agent cannot find the right knowledge, adapt retrieval
• if the base model itself needs a permanent behavioural patch, adapt the weights