Short answer
In most cases, no. Current enterprise data, documents, policies and operational knowledge should usually remain outside model weights and be retrieved at the right moment through context, RAG, tools or governed queries. Fine-tuning makes more sense when the goal is to change behavior, linguistic specialization, output structure or performance on a stable task, not simply to teach frequently changing facts.
Onni treats knowledge, models and capabilities as separate assets. Knowledge evolves without retraining models, and models change without losing institutional intelligence.
Decision framework
- Facts that change → retrieve them (RAG, tools, governed queries)
- Stable behavior, format or style → consider fine-tuning
- Hard rules → a deterministic engine
Onni principle
Your model is not your knowledge.
Related architecture
- Knowledge
- Retrieval
- Context
- Model gateway
- Open this answer as a page Explore the deep dive: Data & knowledge
AI Strategy · CIO questions
Questions every CIOis asking about AI.
21 decisions, answered in the same order: the short answer, how to decide, the Onni principle and the architecture behind it.
What are you tryingto decide?
21 questions
A Models & knowledge
Short answer
They are not equivalent alternatives. RAG provides knowledge; fine-tuning changes behavior. Use RAG for policies, documents, regulations, products, procedures and information that changes. Consider fine-tuning when enough examples demonstrate specialized, relatively stable behavior. In critical processes, both still need to coexist with deterministic rules, tools and evaluation.
Decision framework
- Need knowledge → RAG
- Need behavior → fine-tuning
- Need guarantees → rules, tools and evaluation
Onni principle
RAG provides knowledge. Fine-tuning changes behavior.
Related architecture
- Knowledge
- Context
- Model gateway
- Evaluation
- Open this answer as a page Explore the deep dive: Data & knowledge
Short answer
When domain requirements, cost, latency, privacy, data residency, scale or behavior economically justify it. Don't build a model merely to call your AI proprietary. The more strategic ownership lies in knowledge, capabilities, rules, data, evaluation and the architecture that allows models to be selected or replaced.
Decision framework
- Cost, latency or scale justify it
- Privacy or data residency require it
- The domain needs behavior a general model cannot reach
- Otherwise: own the layer around the model
Onni principle
Own the architecture that chooses the model.
Related architecture
- Model gateway
- Evaluation
- Routing
- Any model
- Open this answer as a page Explore the deep dive: Sovereignty
Short answer
Decompose it. Some should become retrievable knowledge; some deterministic rules; some capabilities; some tools; some memory; and only a portion may justify model adaptation. The goal isn't to put the entire enterprise inside an LLM. It's to build a Domain Intelligence layer that combines knowledge, rules, data, tools and models at execution time.
Decision framework
- Retrievable knowledge
- Deterministic rules
- Capabilities and tools
- Memory
- Model adaptation, only for what is left
Onni principle
Don't put the enterprise inside an LLM. Build domain intelligence around it.
Related architecture
- Knowledge
- Rules
- Capabilities
- Tools
- Domain intelligence
- Open this answer as a page Explore the deep dive: Data & knowledge
B Agents & automation
Short answer
Use agents when execution requires contextual interpretation, dynamic action selection, tool use, adaptation or coordination across steps. If inputs and rules are predictable and fully deterministic, conventional software or workflows are probably better.
Decision framework
- Predictable inputs, fixed rules → software or a workflow
- Context to interpret, actions to choose, tools to use → an agent
- Both → a deterministic flow with agent steps
Onni principle
Use determinism where you can. Intelligence where you need it.
Related architecture
- Intent
- Capability
- Agent
- Tool
- Policy
- Open this answer as a page Explore the deep dive: Core business
Short answer
When there is genuine separation of expertise, context, responsibility or policy. Creating five agents to execute five sequential prompts is not good architecture. Multi-agent systems make sense when specialized capabilities can be independently discovered, composed, evaluated and governed.
Decision framework
- Real separation of expertise, context, responsibility or policy → several agents
- Sequential prompts → one agent or a workflow
- Each agent discoverable, evaluable and governable on its own
Onni principle
Processes should depend on capabilities, not specific agents.
Related architecture
- Capability registry
- Discovery
- Composition
- Evaluation
- Open this answer as a page Explore the deep dive: Core business
Short answer
Autonomy should be proportional to risk, reversibility and confidence. Reading data may be automatic. Producing a recommendation may also be automatic. Making a payment, changing a medical record, imposing a sanction or creating contractual liability may require approval. The right design isn't “human or AI”; it's determining where human judgment creates value or controls risk.
Decision framework
- Read data → automatic
- Recommend → automatic, reviewed by sampling
- Pay, change records, sanction, commit → human approval
- Scale autonomy by risk, reversibility and confidence
Onni principle
Human-in-the-loop by risk.
Related architecture
- Policy
- Risk tier
- Human decision
- Audit
- Open this answer as a page Explore the deep dive: Trust
C Process & transformation
Short answer
Don't start with document volume or headcount. Analyze effort, repetition, variability, decisions, required knowledge, exceptions, handoffs, current quality, data availability and risk. Then classify each activity as eliminate, automate, augment with AI, keep human or redesign.
Decision framework
- Effort, repetition, variability
- Decisions, knowledge, exceptions, handoffs
- Quality today, data availability, risk
- Classify: eliminate · automate · augment · keep human · redesign
Onni principle
Before automating work, understand work.
Related architecture
- AS-IS
- Diagnosis
- Classification
- TARGET
- Open this answer as a page Explore the deep dive: AI readiness
Short answer
No. Start with processes tied to measurable objectives. And don't document only the formal flow: capture decisions, exceptions, rules, systems, knowledge and informal work. Builder uses that understanding to move from AS-IS to TARGET and turn activities into executable capabilities.
Decision framework
- Start with processes tied to measurable goals
- Capture decisions, exceptions, rules, systems and informal work
- Move AS-IS → TARGET → capabilities
Onni principle
Documented process ≠ real work.
Related architecture
- AS-IS
- TARGET
- Activities
- Capabilities
- Open this answer as a page Explore the deep dive: AI readiness
Short answer
Not automatically. Many steps exist because people and legacy systems had limitations that AI doesn't have. First ask which steps protect risk, which create value and which are merely historical bureaucracy.
Decision framework
- Protects risk → keep it, maybe automate it
- Creates value → augment it
- Historical bureaucracy → eliminate it
Onni principle
Don't automate bureaucracy. Redesign it.
Related architecture
- Intent
- Redesign
- Capabilities
- Execution
- Open this answer as a page Explore the deep dive: Core business
D Data, legacy & integration
Short answer
Not necessarily. AI needs governed access to the right context, not an indiscriminate copy of every dataset. Data can remain in source systems and be accessed through queries, APIs, events, tools or appropriate pipelines.
Decision framework
- Governed access to the right context, not a copy of everything
- Leave data in source systems when that works
- Build pipelines only where analysis needs them
Onni principle
AI needs the right context, not all the data.
Related architecture
- Source systems
- Queries · APIs · Events
- Context
- AI
- Open this answer as a page Explore the deep dive: Legacy
Short answer
Decouple AI from system-specific protocols. Encapsulate systems through APIs, drivers, manifests, events and tools. The AI layer should depend on the required capability, not on internal ERP or mainframe details.
Onni implements this principle through manifest + driver and an integration bus that centralizes queries, commands and events.
Decision framework
- Encapsulate by API, driver, manifest, events and tools
- AI depends on the capability, not on the system internals
Onni principle
You don't need to replace your enterprise to become AI-native.
Related architecture
- Integration bus
- Manifest
- Driver
- Events
- Capabilities
- Open this answer as a page Explore the deep dive: Legacy
Short answer
No. MCP standardizes how models and agents discover and use tools and resources. APIs remain fundamental system-to-system contracts. In enterprise architecture, MCP can expose a capability to an agent while an API, event or driver performs the underlying integration.
Decision framework
- MCP: how agents discover and use tools
- APIs, events and drivers: how systems talk
- MCP exposes the capability; the integration runs underneath
Onni principle
Protocols change. Capabilities remain.
Related architecture
- Agent
- MCP
- Capability
- API · Driver
- System
- Open this answer as a page Explore the deep dive: Legacy
E Security & governance
Short answer
Control sensitive data before the model call, not merely through prompting. Detect and pseudonymize data, enforce access policies and rehydrate only at the authorized boundary when necessary. Onni's reference design applies DLP before the LLM call and rehydration at the tool boundary.
Decision framework
- Detect and pseudonymize before the model call
- Enforce access by identity and by row
- Rehydrate only at the authorized tool boundary
Onni principle
Control data before the model, not in the prompt.
Related architecture
- Identity
- RLS
- DLP
- Tool boundary
- Audit
- Open this answer as a page Explore the deep dive: Trust
Short answer
Separate building from publishing. Teams should experiment quickly; production requires identity, versioning, declared capabilities, policies, evaluation, permissions, observability and ownership. Governance stops being a committee reconstructing what happened and becomes part of execution.
Decision framework
- Build freely; publish under control
- Production: identity, version, declared capabilities, policies
- Plus evaluation, permissions, observability and ownership
Onni principle
Governance should be produced by execution, not reconstructed afterward.
Related architecture
- Build
- Evaluate
- Publish
- Registry
- Runtime policy
- Open this answer as a page Explore the deep dive: Trust
Short answer
Record not only the final response but the relevant context: identity, capability, version, model, applied policies, sources, tools executed, human decisions, timestamps, costs and evidence. The architecture should answer not only what happened, but why it happened.
Decision framework
- Who: identity, capability, version
- How: model, policies, sources, tools
- Who else: human decisions
- When and at what cost: timestamps, costs, evidence
Onni principle
Answer why it happened, not just what happened.
Related architecture
- Execution
- Trace
- Evidence
- Atlas
- Open this answer as a page Explore the deep dive: Trust
F Strategy, ROI & sovereignty
Short answer
Start before implementation. Establish baselines for time, cost, quality, volume, rework and human decisions. Then compare the new operation. Hours saved are an operational metric; they become economic value only when they increase capacity, reduce cost, avoid losses or improve a business outcome.
Decision framework
- Baseline before go-live: time, cost, quality, volume, rework
- Compare the new operation against it
- Hours saved count only as capacity, cost, avoided loss or a better outcome
Onni principle
Without a baseline, productivity is an opinion.
Related architecture
- Baseline
- Execution
- Telemetry
- Value
- Open this answer as a page Explore the deep dive: People
Short answer
Because proving that a model can answer well is different from operating an enterprise capability. Production requires integration, ownership, security, evaluation, observability, exception handling, fallback, cost control, SLAs, governance and continuous operations.
Decision framework
- A pilot proves the model answers
- Production operates a capability: integration, ownership, security, evaluation
- Plus observability, exceptions, fallback, cost, SLA and operations
Onni principle
A demo is a model. Production is a capability.
Related architecture
- Pilot
- Capability
- Integration
- Operations
- Open this answer as a page Explore the deep dive: Core business
Short answer
The right question is rarely binary. Buy commodity and specialized technology where it makes sense. Build what differentiates the business. Integrate both. And preserve as enterprise assets the capabilities, knowledge, policies, evidence and architecture required to keep evolving.
Decision framework
- Buy commodity and specialized technology
- Build what differentiates the business
- Integrate both
- Own capabilities, knowledge, policies, evidence and architecture
Onni principle
Buy technology. Own capabilities.
Related architecture
- Vendors
- Capabilities
- Your architecture
- Open this answer as a page Explore the deep dive: Sovereignty
Short answer
Don't try to eliminate vendors; eliminate unnecessary dependencies. Separate model, knowledge, capability, agent, tool, integration and process. The more your processes depend on contracts and capabilities rather than specific endpoints, the easier technologies become to replace.
Decision framework
- Separate model, knowledge, capability, agent, tool, integration and process
- Processes depend on contracts and capabilities, not endpoints
Onni principle
Eliminate unnecessary dependencies, not vendors.
Related architecture
- Process
- Capability contract
- Gateway
- Any vendor
- Open this answer as a page Explore the deep dive: Sovereignty
Short answer
AI sovereignty is the ability to control and preserve institutional intelligence independently of changing models and vendors. It includes knowledge, data, rules, capabilities, integrations, policies, identity, decisions, evidence and architecture.
Decision framework
- Control knowledge, data, rules, capabilities and integrations
- Keep policies, identity, decisions, evidence and architecture
- Independently of model and vendor
Onni principle
Sovereignty isn't owning everything. It's owning your ability to change.
Related architecture
- Knowledge
- Capabilities
- Policies
- Evidence
- Architecture
- Open this answer as a page Explore the deep dive: Sovereignty
These answers aren’t isolated opinions.There’s an architecture behind them.
See the enterprise architectureThe Onni point of view
Our view onenterprise AI.
- 01
The model is not the architecture.
- 02
Knowledge shouldn't be trapped inside the model.
- 03
Processes should depend on capabilities, not specific agents.
- 04
Governance should be produced by execution, not reconstructed afterward.
- Build once.
- Publish capabilities.
- Discover at runtime.
- Compose dynamically.
- Govern centrally.
- Execute anywhere.
Your AI isn't your LLM.
- It's your knowledge.
- Your processes.
- Your rules.
- Your data.
- Your capabilities.
- Your agents.
- Your decisions.
- Your architecture.
- It's your enterprise intelligence.
· Your AI
Bring the decisionyou are facing now.
We answer it with your architecture, your data and your processes on the table.