← Blog
    ArchitecturePortability

    By Alfie Lambert · · 9 min read

    How to Switch AI Models Without Losing Company Knowledge


    A company starts with ChatGPT for customer support.

    The team adds product rules to the system prompt. Then refund policies. Then escalation logic. Then customer tier definitions. The agent works, so the setup keeps growing.

    A few months later, another team wants Claude for research. The data team wants Gemini for Google Workspace workflows. Security wants to test a self-hosted model for sensitive internal data.

    Changing the model endpoint is usually the easy part.

    The harder work starts when teams realise how much company context has gathered around the first setup: prompts, agent instructions, retrieval pipelines, provider-specific memory, workflow state and assumptions that were never turned into shared knowledge.

    That context often starts life as a quick fix. A refund rule added to a support prompt. A pricing definition copied into a sales agent. A product taxonomy embedded in a research workflow. Six months later, those small decisions have become part of the operating system.

    So when the company wants to try a better model, add a second provider, or move one workflow to a self-hosted model, the question is no longer just whether the model can be changed.

    It is how much company knowledge has to be rebuilt before the switch is safe.

    Model choice is becoming a normal part of AI operations

    Most serious AI teams are unlikely to rely on one model forever.

    That is not because every company needs a complex multi-model architecture from day one. Many do not. A single strong provider can be the right starting point.

    But the market is moving too quickly for company knowledge to live inside one provider's ecosystem.

    Model capability changes. Pricing changes. Context windows change. Tool-calling behaviour changes. Compliance requirements change. Procurement pressure changes. Teams also discover that different models are better suited to different tasks. The best model for coding may not be the best model for internal research. The model a support team prefers may not be the model a data-sensitive workflow can use.

    There are already signs of this pressure. DeepSeek's May 2026 API price cut is one example of how quickly model economics can shift.

    The exact market share numbers will change by the time this article is updated, which is part of the point. Companies do not need to predict which model wins. They need to avoid building their company knowledge in places that only one model can use.

    Model portability is not only an API question. It is a knowledge architecture question.

    Where company context gets trapped

    When a team builds an agent, the context that makes it useful usually ends up wherever it was quickest to put it.

    That is understandable. Early agents are often built under pressure. Someone needs a demo, an internal tool, a support workflow or a research assistant. The team adds context where the system can reach it and moves on.

    Over time, this creates hidden coupling between company knowledge and the first model, provider or framework that used it.

    System prompts

    Business rules, product definitions, customer policies and escalation logic often get hardcoded into prompt templates. This works until the prompt becomes the only place where the rule exists. The prompt may also be tuned around one model's instruction-following style, context limits and failure modes. Moving it to a new model is rarely a clean copy-and-paste job. The same instruction can behave differently across providers, especially once it contains detailed company logic.

    Provider-specific memory

    Model memory can be useful for continuity. It can help an assistant remember user preferences, past conversations and recurring projects. That does not make it a safe home for company knowledge.

    A preference such as "this user likes concise answers" belongs in a different category from "enterprise customers in this segment follow this pricing rule". The first is personal context. The second is organisational knowledge. If the second lives inside a provider-specific memory system, it becomes hard to govern, audit, share across agents, or carry into another model environment.

    Agent instructions and framework state

    Agent frameworks make it easier to build workflows, maintain state and connect tools. They are valuable infrastructure. They can also become places where company knowledge hides.

    A workflow might encode approval logic. A state machine might contain assumptions about customer types. A tool configuration might include a narrow definition of which sources count as reliable. None of this looks like "company knowledge" in the abstract, but agents rely on it to behave correctly. If the company later changes frameworks, those assumptions have to be found, understood and rebuilt.

    Per-agent RAG pipelines

    A RAG pipeline can give an agent access to useful documents. In many cases, that is exactly what is needed. The portability problem appears when every agent builds its own retrieval setup: one vector store for support, another for sales, another for research, another for operations. Each one may use different embeddings, different chunking, different document versions and different metadata standards.

    The company still has retrieval. What it does not have is a shared knowledge layer: the gap a proper data fabric is designed to close.

    Switching the embedding model may mean re-embedding a corpus. Switching the agent may mean rebuilding retrieval logic. Adding another model may mean deciding again which documents it should use, which sources matter, and what happens when the retrieved information conflicts.

    Undocumented prompt chains

    Some of the most important knowledge in an AI system never appears in a knowledge base at all. It lives in prompt chains, examples, comments, few-shot instructions and small pieces of glue logic written by whoever built the first version.

    This is fragile even before a model switch. If the person who wrote it leaves, or the model changes behaviour, the team has to reverse-engineer its own context.

    Team-specific agent setups

    A company can easily end up with several useful agents that do not share the same view of the business. Marketing's agent knows the latest positioning. Sales has a different version in a pitch workflow. Support has a refund policy from last quarter. Finance has the approved policy in a spreadsheet. Operations has a newer process in meeting notes.

    Each agent may be working from plausible context. The problem appears when they start giving different answers to questions that should have one company view.

    Memory, task state and company knowledge solve different problems

    A lot of confusion comes from using "memory" as a broad label for every kind of context.

    That hides an important architectural distinction.

    Type of context
    Conversation or model memory
    What it is useful for
    Remembering user preferences, recurring projects and prior interactions
    Typical scope
    Usually provider, user or workspace-specific
    Why it matters
    Helps continuity and personalisation
    Type of context
    Agent or task state
    What it is useful for
    Tracking steps, intermediate outputs and decisions inside a workflow
    Typical scope
    Usually agent, workflow or session-specific
    Why it matters
    Helps an agent complete a task
    Type of context
    Company knowledge
    What it is useful for
    Approved understanding of how the business works
    Typical scope
    Shared across teams, agents and models
    Why it matters
    Helps agents stay aligned with current organisational truth

    All three are useful. The mistake is treating them as interchangeable.

    A support agent remembering that one customer asked for annual billing is memory. A company-wide rule about who qualifies for annual billing is knowledge.

    A research agent remembering that it summarised a market last week is task context. The approved company positioning for that market is knowledge.

    A user preference about writing style can live close to the assistant. A pricing policy, compliance rule or customer definition should not be trapped inside one assistant's memory; it belongs in shared agent memory the whole system can read.

    The more agents a company runs, the more this distinction matters.

    RAG gives access. It does not decide what the company believes.

    RAG is useful. It solves a real problem: given a query, retrieve relevant material from a set of documents.

    For many internal tools, that is enough to create value. A support agent can find documentation. A research agent can search past reports. An onboarding assistant can retrieve HR policies.

    The difficulty starts when retrieval is asked to do the work of governance.

    If two documents contain different versions of a refund policy, retrieval can surface both. It does not know which one the company has approved.

    If a pricing sheet changed last week, retrieval may find the old version unless the indexing pipeline, metadata and source rules are handled properly.

    If each agent has its own RAG setup, the same question can produce different answers depending on which documents that agent indexed, how they were chunked, and which source appeared most relevant at query time.

    None of this makes RAG bad. It means RAG is not the whole knowledge architecture.

    Retrieval helps agents find content.

    A governed knowledge layer helps agents work from shared, current, source-backed company context.

    What portable company knowledge needs

    If company knowledge is going to survive model switches, provider changes and framework migrations, it needs to be treated as its own layer.

    That layer should not be a collection of prompt fragments. It should not be a pile of documents with embeddings attached. It should not be whichever memory system the first model happened to provide.

    At minimum, portable company knowledge needs a few properties.

    Separate from the model: different providers can query the same organisational context.

    Shared across agents: support, sales, research, finance and operations do not each build their own version of the business.

    Governed: important knowledge can be reviewed, corrected and approved before agents rely on it.

    Structured: agents can understand entities, relationships and rules rather than only retrieve passages of text.

    Source-traceable: teams can see where a fact came from and judge whether it should still be trusted.

    Handles change: policies change, products change, teams change, customers change, positioning changes.

    Reusable: a correction made once should improve the context available to every relevant agent, not create another patch in another prompt.

    Comparing common approaches

    This is a simplified comparison. Specific implementations vary, and strong engineering teams can extend many of these approaches with additional governance and portability layers. The point is not that existing tools are useless. The point is that they solve different parts of the problem.

    Hardcoded system prompts
    Portable across models
    Tied to model
    Governed
    Ad hoc
    Shared across agents
    Per agent
    Handles change
    Manual
    Source traceable
    None
    Multi-agent fit
    Weak
    Provider-specific memory
    Portable across models
    Provider-bound
    Governed
    Limited
    Shared across agents
    Usually weak
    Handles change
    Provider-managed
    Source traceable
    Limited
    Multi-agent fit
    Weak
    Per-agent RAG pipeline
    Portable across models
    Partial
    Governed
    Weak by default
    Shared across agents
    Unless centralised
    Handles change
    Needs discipline
    Source traceable
    Partial
    Multi-agent fit
    Partial
    Central vector database
    Portable across models
    Partial
    Governed
    Needs extra layer
    Shared across agents
    Partial
    Handles change
    Needs workflow
    Source traceable
    Metadata-dependent
    Multi-agent fit
    Partial
    Shared knowledge layer
    Portable across models
    By design
    Governed
    Designed in
    Shared across agents
    Designed for reuse
    Handles change
    Built around updates
    Source traceable
    Source-backed
    Multi-agent fit
    Multi-agent native

    Four dots = strong design fit. Empty = weak / not addressed. Verdicts are directional, not absolute.

    How Oiya fits

    Oiya is building the shared knowledge layer for multi-agent systems.

    It sits between a company's data sources and the agents that need company context to do useful work. The aim is to make organisational knowledge available as governed, evolving context that agents can use across models and workflows.

    That places Oiya above raw documents, search indexes and vector storage. Those layers matter, but they are not where company truth should be managed on their own.

    A knowledge layer gives the company a durable place for approved context: customer definitions, product rules, pricing logic, policies, relationships, team structures, vendor information and other facts agents need to work from.

    Oiya makes this context available to agents through MCP and API, so different models and frameworks can query the same approved organisational knowledge.

    When a team adds a new model, the company should not have to rebuild that knowledge from scratch. The model can change. The knowledge layer remains the place agents query for current company context.

    What Oiya does not remove

    A knowledge layer does not make model switching effortless.

    There is still real engineering work when a company changes models or adds a new provider.

    Prompts may need tuning because models follow instructions differently.

    Evals need to be rerun because output quality and safety can change.

    Tool behaviour needs testing because function calling and integration patterns vary.

    Latency and cost need review because pricing and performance profiles differ.

    Security and compliance teams still need to approve how data moves through the stack.

    Oiya's argument is narrower and more practical: the company knowledge agents depend on should not have to be reconstructed for every model or framework change.

    If the organisational context, approved facts, policies and relationships live in a shared knowledge layer, teams can change the model layer without treating every switch like a knowledge management migration project.

    What to ask before switching models

    Any team evaluating a model change should start with the context around the model, not only the model itself. Ten questions worth answering before the migration ticket opens.

    1. Where does our company context currently live?
    2. Which facts are duplicated across prompts, agents or retrieval systems?
    3. Which source is authoritative when two agents disagree?
    4. What happens when a company policy changes?
    5. Can another model access the same approved context as the current model?
    6. Can we trace an agent's answer back to the source it relied on?
    7. Are we storing company knowledge in provider-specific memory?
    8. Are we rebuilding knowledge infrastructure every time we add an agent?
    9. Which parts of our context are personal preference, task state or company knowledge?
    10. Is our knowledge governed, or merely retrievable?

    If these questions are hard to answer, the company may already have more knowledge lock-in than it realises.

    The durable part of the AI stack should be company knowledge

    Models will keep changing.

    Some will get cheaper. Some will get better at reasoning. Some will be preferred for coding, research, multimodal work, data-sensitive workloads or internal automation. Some providers will become more attractive commercially. Others will become harder to justify.

    A company should be able to respond to that market without rebuilding the knowledge that makes its agents useful.

    The durable layer is not the model. It is the company's accumulated understanding of its own business: policies, definitions, relationships, rules, source-backed facts and approved context.

    That knowledge should compound as the organisation corrects it, approves it, structures it and reuses it across agent workflows.

    If your company is building agents across multiple models or frameworks, the practical move is to separate the knowledge layer from the model layer.

    Oiya is being built for that separation: shared, governed company context that agents can use as the model stack changes around it.

    FAQ

    Can I switch from ChatGPT to Claude without losing company knowledge?

    Yes, but only if the company knowledge your agents rely on lives outside the model provider. If important context is stored in provider-specific memory, system prompts, model-specific configurations or isolated retrieval pipelines, switching models can mean rebuilding that context. A model-agnostic knowledge layer gives different agents and providers access to the same governed company context.

    What is a model-agnostic knowledge layer?

    A model-agnostic knowledge layer stores and serves company context independently of the model that queries it. Instead of embedding company knowledge inside one model, one provider or one agent framework, the knowledge layer becomes the shared place where agents access approved facts, policies, definitions and relationships.

    Is RAG enough to make AI agents model-agnostic?

    RAG can help agents retrieve relevant documents across model providers, but it does not automatically solve governance, approval, source authority or consistency across agents. If each agent has its own RAG pipeline, knowledge can still diverge. A governed knowledge layer sits above retrieval and gives agents shared context they can rely on across workflows.

    What is knowledge divergence in multi-agent AI?

    Knowledge divergence happens when multiple agents inside the same company operate from different context, sources or assumptions. One agent may use an old policy. Another may use a newer one. A third may rely on a prompt that no one has reviewed for months. The agents may all appear useful in isolation, but the company loses a shared view of what is true.

    How do I avoid AI vendor lock-in with company knowledge?

    Keep company knowledge separate from the model layer. That means avoiding a setup where important context only exists in one provider's memory, one prompt stack, one agent framework or one retrieval pipeline. Store organisational knowledge in a governed layer that different models and agents can query.

    What is the difference between model memory and company knowledge?

    Model memory is useful for continuity, preferences and past interactions. Company knowledge is the organisation's approved understanding of how the business works. A preference such as writing style can live close to the assistant. A pricing rule, compliance policy, product taxonomy or customer definition should be governed, source-backed and shared across agents.

    Oiya is the shared knowledge layer that keeps company context portable across models, providers and frameworks. If you're evaluating a new model or running agents across more than one, book a 30-minute call.

    Related