Migrating pipelines and agents
Batch jobs, eval harnesses, guardrails, tool definitions and few-shot examples across a provider boundary.
Moving a single chat completion to another provider is an afternoon. Moving the machinery around it is not. A production pipeline carries a batch submitter that assumes one job lifecycle, an eval harness whose scores only mean something relative to the runs before it, a guardrails config written in one vendor’s safety vocabulary, a set of tool definitions in one schema dialect, and a body of prompts shaped by idioms the old model responded to. None of that is in the request body, and none of it moves by editing a base URL.
These pages work through that layer one piece at a time. The useful part of any mapping is the part that does not survive it: the status value with no counterpart, the parameter that means something subtly different, the default that differs, the capability one side has and the other does not. Each page names what is lost, what you rebuild by hand, and how you tell whether the rebuild worked before you cut traffic over.
Migrating Long-Running Batch Jobs Between Provider Batch APIs
How submission, polling and result retrieval differ between file-based and inline batch APIs, and how to rewrite a working batch script for a new target.
11 min read
Mapping Batch Job Status Values Between Providers
What each batch status value means, which ones are terminal, and why several have no counterpart on the other side at all.
10 min read
Migrating an Evaluation Harness to a New Provider
Why eval scores drop after a provider swap when the model is fine, and how to tell a real capability change from a harness artefact.
11 min read
Migrating a Guardrails Configuration Between Providers
How to rebuild a moderation ruleset when the target provider's safety categories are named differently, scoped differently, or do not exist as a configurable surface at all.
11 min read
What a Migration Does to Your Prompt Injection Defences
An argument that injection defences split into an architectural class that transfers intact and a behavioural class that does not, and that only the second needs re-testing.
10 min read
Migrating a Function-Calling Agent's Tool Definitions
A field-by-field conversion of tool definitions between provider schemas, including the result-message shape that changes with them.
11 min read
Why an Agent's Tool-Choice Behaviour Changes After a Provider Swap
Why an agent starts selecting the wrong tool when the definitions are byte-identical, and how to separate a translation bug from a genuine difference in tool-use behaviour.
10 min read
Mapping the "tool_choice" Parameter Between APIs
What each tool_choice value does, how the equivalents are spelled across API shapes, and which options exist on one side only.
10 min read
Migrating Response Format Enforcement ("json_object") Between Providers
What to do when response_format json_object is rejected on a migration target, and how to approximate the guarantee it gave you.
11 min read
What Changes in Refusal Behaviour After a Model Migration
How to detect, measure and reduce a refusal spike after a model swap, including the signals that distinguish a refusal from an ordinary short answer.
11 min read
Testing for Refusal Rate Changes Before Committing to a Migration
How to build a borderline prompt set from your own traffic and measure the refusal rate on both models, so a policy shift shows up in a test run rather than in support tickets.
10 min read
Conversation Summarization Breaks After a Provider Switch
Why a summarization prompt tuned to one model's compression habits produces summaries of the wrong length after a swap, and how to re-anchor it to a budget the model cannot reinterpret.
10 min read
Auditing Token Budget Assumptions Baked Into Chunking Logic
Why a chunker sized in characters or against a stale encoding starts producing oversized chunks after a model change, and how to find and re-derive every budget in the pipeline.
10 min read
Migrating Chunk Size Strategy When You Change Embedding Models
Why the chunk size that worked for one embedding model is not automatically right for another, and the arithmetic for re-deriving it and costing the re-index.
10 min read
Migrating an Agent Framework's Memory Store Format
How to convert stored agent conversation state between two frameworks' persistence schemas without breaking the tool-call invariants the target API will reject.
11 min read
What a Model Family Is, and Why Prompts Do Not Transfer Across One
Defines a model family by shared training lineage rather than shared vendor, and explains why that boundary predicts prompt portability better than the API you call.
9 min read
Auditing a Prompt Library for Provider-Specific Idioms
A review pass over stored prompts that flags the phrases, delimiters and hidden parameter dependencies that will not carry to another model family.
11 min read
Rewriting XML-Delimited Prompts for a Model That Does Not Favour XML
How to convert a prompt built on XML tags into a different delimiter convention without losing the boundary guarantees the tags were providing.
10 min read
Few-Shot Examples Stop Working After Switching Models
Why an example set tuned to one model's formatting habits degrades on another, and the specific adjustments — turn structure, count, balance, stylistic residue — that usually recover it.
10 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models