Cutting over between providers
Dual-running, fine-tune translation, prompt portability and the cost re-baselining that follows a switch.
A provider switch is usually planned as an integration job and turns out to be four jobs. The API shape is the visible one and the smallest: rename a field, move the system prompt, adjust a stop-sequence array. Underneath it sit three that nobody scoped. The prompt was tuned against one model family and its formatting conventions do not carry. The fine-tune does not move at all. And the cost model, which was built by multiplying a measured token count by a known price, is now wrong in both factors at once — different tokenizer, different table — in a way that can move the bill in either direction.
These pages are about that second layer. Each one starts from a thing that does not translate, explains why it does not, and gets to what you rebuild instead. Where a page needs a number that only your own traffic can supply, it gives you the procedure that produces it rather than a figure borrowed from somebody else’s workload.
Translating a Fine-Tune When You Change Base Providers
A fine-tune is a delta on one specific base model, so nothing about it crosses to another provider except the data that produced it.
9 min read
Re-Running a Fine-Tune Job on a New Provider's API
Converting a supervised fine-tuning dataset between the two dominant JSONL shapes, field by field, including the parts that have no counterpart.
10 min read
Prompt Portability: What Breaks When You Move a Prompt to Another Model Family
The specific prompt constructs that are tuned to one model family's post-training and degrade on another, and what to change first.
10 min read
Re-Baselining Cost Estimates After Switching Providers
A procedure for rebuilding a cost model after a switch, when price, tokenizer and typical output length have all moved at the same time.
10 min read
Why the Same Prompt Costs a Different Amount on Two Providers
The cost difference for one identical request decomposes into a tokenizer ratio and a price ratio, and the two can point in opposite directions.
9 min read
Rate Limit Differences You Hit When Switching Providers
Rate limits vary along four independent axes — unit, window, scope and tier — and a migration usually breaks on the axis nobody checked.
9 min read
Why Your Token Count Changed After Switching Providers
Identical text produces different token counts on different providers because each model family has its own learned vocabulary, and three other effects add to the gap.
9 min read
What a Tokenizer Difference Does to Your Monthly Bill
Turning a measured per-request token ratio into a monthly figure, and the aggregation errors that make the naive multiplication wrong.
10 min read
Moving Off a Managed AI Platform: What You Actually Own
Ownership of an AI artifact is reproducibility, not a download button, and that distinction decides what survives the day you leave.
10 min read
Exporting Conversation History and Normalising It
The two shapes chat exports actually take, and a transform that turns either into a plain message array you can replay anywhere.
10 min read
What Conversation History Exports Leave Out
The fields a chat export typically drops, the migration decision each one blocks, and where to capture it instead.
9 min read
A Vendor Lock-In Checklist, Component by Component
Score each layer of an AI stack on five questions instead of treating lock-in as one property of one vendor.
10 min read
Which Parts of an AI Stack Are Actually Portable
Portability is a property of the representation, not of the vendor, and that is why it is so uneven across one stack.
9 min read
Contract Terms Worth Checking Before You Commit to an AI Vendor
The clause types that decide how hard a future migration will be, read through the single lens of what each one costs you at exit.
10 min read
Minimum Commitment Clauses in AI Vendor Contracts
How volume commitments are structured, and the arithmetic that turns a headline discount into a premium when usage falls short.
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
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- 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