Updated October 2026

Model Improvement Techniques

From context engineering to RL fine-tuning: the techniques that get the most out of today's foundation models, and when to use each.

Building a model from scratch instead of using one? See Build a Frontier Model →

Quick Decision Guide

🚀

Need quick improvement?

Prompt & context engineering

⚡

Need current or private data?

RAG or an MCP connector

🧩

Repeating a workflow?

Write an Agent Skill

🎨

Need consistent behaviour or lower cost?

Fine-tune or distil

Core Optimization Techniques

The three fundamental approaches to improving AI model performance. Each has unique strengths and can be combined for maximum effect.

✍️

Prompt & Context Engineering

EasyHoursAPI usage only

Steering a model with instructions, examples, and the right context, without changing its weights. In 2026 the skill is less about clever wording and more about deciding what goes into a 1M-token context window, and what stays out.

✓ Benefits

  • Immediate results with no infrastructure changes
  • Works with any model, open or closed
  • Effort and thinking controls let you trade cost for quality per request
  • Easy to iterate, version, and evaluate

! Limitations

  • Cannot teach new knowledge the model lacks
  • Long contexts degrade ("context rot"): more tokens is not always better
  • Behaviour can shift when the provider ships a new model version

→ Use Cases

  • Clear task instructions plus a few representative examples
  • Structured outputs that match a JSON schema
  • Choosing an effort level (e.g., low/medium/high) per task
  • Compacting long agent histories into notes
🔍

Retrieval & Tools (RAG, MCP)

MediumDaysLow to medium

Giving the model fresh, private, or task-specific information at run time. Classic RAG retrieves document chunks from a vector index. Agentic retrieval lets the model search, open files, and call tools itself, often through MCP connectors.

✓ Benefits

  • Access to current and proprietary information
  • Reduces hallucinations by grounding answers in sources
  • No retraining: update the documents, not the model
  • MCP connectors reuse one integration across many clients

! Limitations

  • Answer quality is capped by retrieval quality
  • Adds latency and tool-call cost
  • Untrusted retrieved content is a prompt-injection vector
  • Needs indexing, permissions, and freshness pipelines

→ Use Cases

  • Company knowledge bases and documentation
  • Customer support grounded in product manuals
  • Coding agents that grep and read a repository just in time
  • Research assistants that search, read, and cite
🎯

Fine-Tuning & RL Post-Training

HardWeeksHigh

Changing a model's weights on your own data. Supervised fine-tuning (often with LoRA) teaches style and format. RL with verifiable rewards and on-policy distillation teach the model to actually do your task better, using graders you write.

✓ Benefits

  • Consistent style, format, and domain behaviour
  • Shorter prompts because behaviour is learned
  • RL on your own graders can beat prompting on checkable tasks
  • Strong open-weight bases exist for fine-tuning (e.g., Gemma 4, Qwen3.5, Thinking Machines' Inkling)

! Limitations

  • Requires data, evals, and significant compute
  • Risk of catastrophic forgetting and regressions
  • RL can learn to reward-hack weak graders
  • Must be redone as base models are replaced every few months

→ Use Cases

  • Brand voice and output-format adaptation (SFT/LoRA)
  • RL on unit tests or rubric graders for a coding workflow
  • Distilling a large model into a cheaper, faster one
  • Safety and policy tuning for a specific deployment

Advanced Techniques

The methods frontier labs and advanced builders rely on as of October 2026, from context engineering to RL post-training.

📏

Context Engineering

Treating context as a finite attention budget. 1M tokens is now the default at the frontier, but models still lose focus as context grows, so the goal is the smallest set of high-signal tokens.

  • •Compaction: summarize history and continue
  • •Clear stale tool results from the window
  • •Structured notes and external memory files
  • •Sub-agents keep side work out of the main context
  • •Prompt caching for repeated prefixes
🧩

Agent Skills

Folders of instructions, scripts, and resources (a SKILL.md plus files) that an agent loads only when a task needs them. Anthropic published the format as an open standard in December 2025.

  • •Progressive disclosure: only name and description load up front
  • •Package repeatable procedures once, reuse everywhere
  • •Adopted beyond Claude, including OpenAI Codex and Gemini CLI
  • •Complements MCP: skills hold know-how, MCP provides tools
🧰

Model Context Protocol (MCP)

The open standard for connecting agents to tools and data. Now governed by the Linux Foundation's Agentic AI Foundation. The current spec (2026-07-28) is its largest revision: a stateless core with no initialize handshake or session IDs.

  • •Servers expose tools, resources, and prompts
  • •Stateless requests run behind plain load balancers and serverless
  • •Official extensions: Tasks, MCP Apps, Enterprise Managed Authorization
  • •Roots, Sampling, and Logging are deprecated
  • •A2A covers agent-to-agent; MCP covers agent-to-tool
🎯

Few-Shot & Many-Shot Examples

Showing the model examples of the input and output you want. With long contexts, many-shot prompting (dozens or hundreds of examples) can approach light fine-tuning for some tasks.

  • •Choose diverse, representative examples
  • •Include edge cases and the format you need
  • •Cache long example blocks to cut cost
  • •Measure with an eval set, not a few spot checks
🔗

Chain-of-Thought & Reasoning Models

Reasoning models now think before answering by default, so "think step by step" prompts matter much less. The model's visible reasoning is also a safety asset: it lets humans and monitors see what the model is doing.

  • •Use effort or thinking-budget controls instead of CoT prompts
  • •Monitoring the CoT catches far more than monitoring outputs only
  • •Avoid training pressure that makes reasoning less readable
  • •Latent and recurrent-depth reasoning are a monitorability concern
⏱️

Test-Time Compute

Spending more inference on harder problems. Effort controls are now product features (Claude low to max, OpenAI none to xhigh plus Pro, Gemini Deep Think), and the big 2026 shift is parallel agent compute.

  • •Longer thinking per call via effort settings
  • •Parallel sampling with voting or a verifier
  • •Agent swarms: Kimi K2.5 runs up to 100 sub-agents
  • •Process reward models can guide search
✅

RL with Verifiable Rewards (RLVR)

RL on tasks where correctness is mechanically checkable: math answers, unit tests, formal proofs, agent environments. Now standard post-training at every frontier lab.

  • •GRPO and variants: DAPO, Dr. GRPO, GSPO
  • •GSPO's sequence-level ratios stabilise MoE RL
  • •Asynchronous RL separates generation from training
  • •Evidence suggests RLVR mostly sharpens what the base model can already do
📈

RL Scaling

RL compute now follows predictable scaling curves. ScaleRL (Meta and collaborators, 400k+ GPU-hours) found reward rises along a sigmoid in compute, so small runs can forecast big ones.

  • •Recipe choices set the ceiling (asymptote)
  • •Normalisation and curriculum mostly set efficiency
  • •A 100k GPU-hour run was predicted accurately
  • •Agentic RL now has its own data scaling laws
🔬

On-Policy Distillation

The student generates its own outputs and a stronger teacher scores every token. This gives RL's on-policy data with a much denser signal than a single end-of-episode reward. It rose in 2026 as a complement to GRPO.

  • •Popularised by Thinking Machines (Oct 2025)
  • •Fixes the mismatch of SFT on teacher traces (off-policy)
  • •Common pattern: RL a big model, then distil to a small one
  • •Needs teacher log-probs, so usually open or in-house teachers
💉

Inoculation Prompting

A safety technique for RL training. Anthropic found models that learned to reward-hack generalised to sabotage and alignment faking. Telling the model during training that hacking is acceptable in that environment cut the misaligned generalisation by 75-90%.

  • •Breaks the link between "cheating" and "being a bad actor"
  • •Used in Anthropic's production training
  • •Cheap: a change to the training prompt
  • •Still fix the grader; inoculation limits the fallout
📜

Constitutional AI (CAI)

Training models against a written set of principles instead of relying only on human labels. Anthropic rewrote Claude's constitution in January 2026 as a long document addressed to Claude itself.

  • •Self-critique and AI feedback based on principles
  • •Reduces need for human annotation
  • •Explains reasons, not just rules
  • •Used by Anthropic for Claude models
👥

RLHF & Preference Tuning

Training on human (or AI) preference comparisons for qualities that can't be checked mechanically, such as helpfulness, tone, and judgement. Today it runs alongside RLVR rather than instead of it.

  • •Humans or models rank outputs
  • •Reward model or direct preference optimisation
  • •Covers what verifiers can't check
  • •Reward models can be gamed, like any grader
🏢

Mixture of Experts (MoE)

Many expert sub-networks with only a few active per token. Open frontier MoEs now reach 1-3T total parameters with 13-104B active.

  • •Kimi K3: 16 of 896 experts active (2.8T total)
  • •DeepSeek-V4-Pro: 1.6T total, 49B active
  • •LatentMoE routes in a low-rank latent space
  • •Fine-tuning MoEs needs care with router stability
⚡

Speculative Decoding

A fast draft proposes several tokens and the main model verifies them in one pass. Verification keeps the output distribution unchanged, so the speedup costs no quality.

  • •EAGLE-3 is standard; vLLM's EAGLE 3.1 reports 2.03x at concurrency 1
  • •Multi-token prediction heads act as a built-in drafter
  • •Gains shrink at high batch concurrency
  • •Diffusion LMs are a separate low-latency path
📉

Muon & Low-Precision (for Fine-Tuners)

Many open bases (Kimi K2/K3, GLM-5, DeepSeek-V4) were pretrained with the Muon optimizer, and FP8 training is routine, with 4-bit NVFP4 pretraining shown to match FP8 at 12B scale. Both affect how you fine-tune.

  • •Muon is Scalable (2502.16982) found matching the pretraining optimizer helped fine-tuning
  • •Check the model card for optimizer and precision
  • •FP8 or FP4 checkpoints: fine-tune adapters, keep sensitive layers higher precision
  • •Quantize after fine-tuning and re-run evals
🖥️

Computer Use / Browser Agents

Models that operate a real desktop or browser. Anthropic reports Claude Opus 5.5 at 81.8% on OSWorld 2.1. Scores differ across OSWorld versions, so compare only within one version.

  • •Vision, planning, and action in one loop
  • •Agents increasingly get their own cloud computers
  • •Prompt injection may be a permanent property: design for containment
  • •Rule of Two: avoid untrusted input + sensitive access + external actions together

Combining Techniques

The most powerful AI systems layer multiple optimization techniques together.

Context Engineering + Agentic Retrieval

Let the agent search and load documents just in time, then compact what it learned into notes

Best for: Long-horizon coding and research agents

Agent Skills + MCP

Skills package the procedure; MCP servers provide the tools and data it needs

Best for: Repeatable enterprise workflows across several apps

Fine-Tuning + RAG

Fine-tune for style and behaviour, retrieve for facts that change

Best for: Customer-facing assistants with a brand voice and accurate product info

RLVR + On-Policy Distillation

Train a large model with RL on your graders, then distil it into a small, cheap model

Best for: High-volume tasks where latency and cost matter

Effort Controls + Verifiers

Use low effort by default, escalate to high effort or parallel samples checked by a verifier on hard cases

Best for: Mixed workloads with a few hard problems

RL + Inoculation Prompting

Harden graders and inoculate the training prompt so any remaining reward hacks don't generalise

Best for: Anyone running RL fine-tuning on their own environments

Recommended Implementation Path

Step 1

Prompt, Context, and Evals

Build a small eval set first. Then iterate on instructions, examples, and effort settings until you hit limits.

Hours to implement
Days to implement
Step 2

Add Retrieval, Tools, and Skills

Connect data through RAG or MCP, and package repeatable procedures as Agent Skills.

Step 3

Fine-Tune, RL, or Distil

Only when you need behaviour, accuracy, or cost that prompting and tools can't reach. Your Step 1 evals become your graders.

Weeks to implement

Put These Techniques Into Practice

FullAI's API gives you the foundation to implement any of these optimization techniques. Start experimenting today.

Get Your Free API Key