November 18, 2026 in platform, architecture by Dimitri Tombroff and Fred Team14 minutes
Most AI assistants treat data as temporary context. We built Fred around a different premise: data has an owner, a state and a lifecycle. Here is how that sets Fred apart from Open WebUI, IBM Bob and Coday/AgentOS, with a side-by-side table.
We are often asked a simple question: how is Fred different from Open WebUI? Sometimes the name is IBM Bob, sometimes Coday or its AgentOS service. The question is fair. All of these tools put AI assistants in front of people, all of them can use several models, and all of them talk about agents.
These three were not picked at random. Each represents a family of tools that people naturally compare Fred with: the open-source chat interface, the established vendor and the open-source developer initiative. Together with our earlier comparison with OpenAI, Anthropic, Microsoft and Salesforce, they give a fair picture of where Fred stands.
The short answer is that they solve different problems. Comparing feature lists hides that. This article starts from the question each tool answers, then gives a side-by-side table, and ends with what makes Fred distinctive.
Most AI assistants treat data as temporary context. We built Fred around a different premise: data has an owner, a state and a lifecycle, recorded in a governed data catalogue at the platform’s core.
| Tool | Family | The question it answers |
|---|---|---|
| Open WebUI | Open-source chat interface | How do I give my users a rich, self-hosted chat interface to any model? |
| IBM Bob | Established vendor | How do I help an enterprise development team build, modernize and ship software with AI? |
| Coday / AgentOS | Open-source developer initiative | How do I, as a developer, work with agents on my codebase, or embed agent orchestration in my product? |
| Fred | Open-source governed platform | How do teams, their documents, their agents and the data those agents produce share one governed lifecycle on our own infrastructure? |
Two of these tools serve software developers. Open WebUI and Fred serve people working with knowledge. Even there, the emphasis differs: Open WebUI centres on the conversation, Fred on the space where a team’s resources and data live.
Fred is released under the Apache 2.0 license and runs on Kubernetes, with Helm charts, PostgreSQL, object storage, a search index and Temporal for durable processing. People sign in through the organization’s own OpenID Connect provider; Keycloak is supported but optional. Every component can run on your own cluster, including disconnected environments, with the models your organization approves. The models used to process documents, for OCR, reranking and audio transcription, run inside Fred and send no document to an external provider.
That alone is not a differentiator. Open WebUI is self-hosted and has Helm charts. Coday is MIT-licensed. IBM Bob now offers self-hosted and air-gapped deployment. Being open and deployable is the baseline. The real differences are in what each tool considers its core.
Information about other tools comes from their public documentation, consulted on November 18, 2026 (see the references). Tools evolve quickly; corrections are welcome.
| Fred | Open WebUI | IBM Bob | Coday / AgentOS | |
|---|---|---|---|---|
| Core | Governed spaces with their resources and data | Chat interface to models | AI partner for the software lifecycle | Agent framework for developers; agent orchestration service |
| Interface | Organized by place of work: each space gathers its agents, resources, Wiki, applications and members | Organized by object type: models, knowledge, prompts, tools | IDE and the Bob Shell command line | Web chat on a project (Coday); REST API (AgentOS) |
| Primary users | Organizations and their teams | Individuals and teams of an instance | Enterprise developers | Developers; product teams embedding agents |
| Unit of collaboration | Organization, team, project and personal spaces, with roles per space | Users, groups and per-resource permissions | Repository and development workflow | Project directory (Coday); namespaces and cases (AgentOS) |
| Agents | Agent Pods in Python or Rust, your own pods, external MCP tools, scoped delegation | Model presets with instructions, tools and knowledge | Built-in modes (Code, Plan, Orchestrator…), multi-agent workflows | Agents declared in YAML or Kotlin plugins, MCP tools |
| Documents and knowledge | Space drives, durable processing, Knowledge Base mirrors of external sources, team Wiki | Knowledge collections from uploaded files, hybrid search | Source code and enterprise systems | Project files and persistent context |
| Data produced by agents | Catalogued: working files, published deliverables, Wiki proposals that a human approves, with provenance | Chat history, notes and memory | Code changes reviewed through human checkpoints | Conversation and file exchange per case |
| Model governance | Per organization, decided for every turn by the Control Plane; credentials never reach the browser | Administrator chooses connections and model access | Multi-model routing managed by Bob | Provider keys configured per installation |
| Business applications | Hosted applications embedded in a team’s space | Functions and pipelines extend the chat | Specialized modernization workflows | AgentOS embedded in a host product (Whoz) |
| Deployment | Kubernetes, Helm, self-hosted | Docker, pip, Helm | IBM SaaS or self-hosted | Local npx web server; Docker for AgentOS |
| License | Apache 2.0 | Open WebUI License: BSD-3 plus a branding clause above 50 users; not OSI-approved | Proprietary | MIT |
The table shows complementary rather than overlapping tools. A team can code with Bob or Coday and use Fred to manage the knowledge its business relies on. Open WebUI is the closest comparison, and the one where the difference in approach matters most.
Most assistants treat data as context: files are uploaded, indexed and offered to the model. In Fred, data is a resource with an owner, a state and a history. Fred’s Control Plane keeps that history in PostgreSQL: where every document belongs, which processing attempts ran, which results were produced, which were published, and what was deleted and when. File bytes live in object storage; the catalogue records their placement and state.
flowchart TB
subgraph space["A team's space"]
direction TB
upload["Uploaded document
Original preserved"]
mirror["Knowledge Base mirror
Synchronized from an external source"]
process["Processing attempt
Extract and index"]
published["Published result
Searchable by authorized agents"]
work["Agent working files
Private to the conversation"]
proposal["Wiki proposal
Drafted by an agent"]
wiki["Team Wiki page
Approved, with provenance"]
end
catalogue[("Control Plane catalogue
PostgreSQL")]
upload --> process
mirror --> process
process -->|"Accepted"| published
work -->|"Human approval"| proposal
proposal --> wiki
catalogue -.->|"Placement, state, provenance"| space
classDef fred fill:#DBEAFE,stroke:#2563EB,color:#172554
classDef cots fill:#FEF3C7,stroke:#B45309,color:#451A03
class upload,mirror,process,published,work,proposal,wiki fred
class catalogue cots
Figure 1. One catalogue for documents, synchronized sources and agent contributions. Simplified from the Fred architecture documentation.
This catalogue is what makes a few simple rules enforceable:
Many of these rules are checked by the database itself, through constraints and triggers, not only by application code. This is the part of Fred we consider most original. A chat interface cannot easily retrofit it: it must be designed into the platform from the start.
An agent platform without a serious knowledge stack does not go far. Dedicated projects such as Onyx, Dify and RAGFlow show that the industry agrees. Fred ships one by default: Knowledge Flow processes documents, combines semantic and keyword search, and answers SQL queries over tables stored as Parquet files in object storage. Text and tables follow the same access rules.
Knowledge Flow holds no authority of its own. The Control Plane decides access and publication; search indexes are projections of the catalogue. This is what makes the knowledge layer open to others:
Documents are only the starting point. Fred already turns them into forms suited to AI, Markdown text and Parquet tables. Increasingly, knowledge will be produced directly in such forms, by people and by agents.
In Open WebUI, an agent is mainly a model preset: a model, a prompt, some tools and some knowledge. In Fred, an agent runs in an Agent Pod, a separate workload that is admitted for every turn. The Control Plane decides which model it may use, which documents it may search and which tools it may call, from the space and the person on whose behalf it acts.
This separation has practical consequences:
Consumption follows the same discipline. Agents report the tokens they use to the Control Plane, which records each report once, in SQL, against the person, space, agent and model. People and team leads follow their usage with cost, energy and CO2e estimates: frugality becomes something you can measure.
The result is a platform where the organization defines the rules, and agents, applications and connectors work within them.
Because data, models and tools are governed, what agents deliver can be governed too: their deliverables become reliable, auditable objects rather than files produced on the fly.
Generating a PowerPoint file is no longer remarkable. In Open WebUI, a model can write Python code with python-pptx in a sandbox, and community tools fill corporate templates. That approach is flexible; the result depends on the model and on the tool chosen.
Fred takes the opposite approach: a few capabilities, each with a contract on its result. The presentation builder is the clearest example:
The same discipline applies to the documents an agent writes beside the conversation and to the web pages it produces. Web pages are rendered without JavaScript, a deliberate security choice. What a model alone cannot guarantee, respect for the template, provenance and a reliable revision process, is what Fred’s capabilities provide.
Most multi-agent systems today coordinate through messages: one agent hands a task to another, asks a question, and waits for an answer. Fred already supports this, with scoped delegation that ensures a specialist sees only what the caller was allowed to see.
Messages, however, are short-lived. Once the conversation ends, the reasoning and the intermediate results are often lost. We are now exploring a different form of collaboration, built on the data catalogue: agents contribute durable, governed data that other agents and people can find, verify and reuse.
flowchart TB
subgraph messages["Coordination by messages"]
direction TB
a1["Agent A"] -->|"Asks"| b1["Agent B"]
b1 -->|"Answers"| a1
end
subgraph data["Collaboration through data"]
direction TB
a2["Agent A"] -->|"Contributes"| d["Catalogued result
Owner, state, provenance"]
d -->|"Reused within rights"| b2["Agent B"]
d -->|"Reviewed"| p["Team members"]
end
classDef neutral fill:#F1F5F9,stroke:#64748B,color:#0F172A
classDef fred fill:#DBEAFE,stroke:#2563EB,color:#172554
class a1,b1,a2,b2,p neutral
class d fred
Figure 2. The direction we are exploring: a result produced by one agent becomes a governed resource for the rest of the team.
The building blocks exist: published deliverables with stable identities, Wiki proposals approved by people, and provenance preserved in the catalogue. The question we want Fred to answer is how knowledge produced in a conversation becomes knowledge the team, then the organization, can rely on. Our working hypothesis is a governed promotion cycle: an immutable copy, with its provenance, is promoted from a conversation to a team collection, then to the organization, by a person with the right role or by a space policy. An agent reuses what has been promoted to the level where it works. The roadmap details this direction; future articles will follow its progress.
The questions ahead are among the most interesting in this field, and among the hardest. How should knowledge produced with an agent earn the trust of a team, then of an organization? What should a governed collection contain, and what should stay inside the engines that build it? How can agents build on each other’s work without exchanging more than they are entitled to see? How do we keep all of this frugal enough to run anywhere, from a large cluster to a small embedded deployment?
We do not have all the answers, and we would rather find them with others. Fred is built in the open, and the architecture documentation explains each boundary described here. There are many ways to take part:
Researchers, students and industrial teams are all welcome. Join us on GitHub to start the conversation.
Documentation consulted on November 18, 2026. Summaries are paraphrases, not quotations.