Skip to main content

What Git did for code, KnowledgeFund may need to do for organisations

· 5 min read

Git did not succeed because people suddenly became better at writing code.

It succeeded because it gave code work a structure that could scale.

Version history. Branching. Merging. Review. Shared source of truth. Traceability of change. A practical way for multiple people to work on the same evolving body of logic without collapsing into chaos.

It did not remove complexity. It made complexity more governable.

That matters now, because organisations are heading into a similar problem with AI.

The issue is no longer just whether people have access to models, copilots, or agents. The issue is whether the organisation has a structure that AI can actually work with.

And in most cases, it does not.

Organisations are full of trapped knowledge

Most organisations are not short of information.

They are short of structure.

Knowledge sits in documents, chat threads, inboxes, systems, habits, unwritten rules, local workarounds, and people’s heads. Decisions are made in one place and felt in another. Teams build fixes without knowing what already exists. Context is interpreted repeatedly, inconsistently, and often too late.

This has always been a problem, but AI makes it impossible to ignore.

AI systems need legibility. They need structure. They need to know what things are, how they relate, what matters, where authority sits, what changed, and what evidence connects one action to another.

Without that, AI does not create coherence.

It amplifies fragmentation.

You cannot just turn a company into a giant repo

One tempting response is to say: fine, let’s treat the organisation like a repository.

There is something right about that.

An organisation does contain evolving work, decisions, context, standards, dependencies, and change history. It does need traceability. It does need shared understanding. It does need a way for many contributors to work on a living system.

But if you simply start dumping organisational knowledge into an AI-accessible store, you do not get order.

You get a bigger mess.

Raw accumulation is not structure.

A company is not just a pile of content. It is a living system of meaning, action, incentives, constraints, roles, judgments, and contested priorities. If you expose all of that without an organising logic, you create sludge, not clarity.

That is why the repo analogy is useful, but incomplete.

The missing piece is ontology

Code works in Git because code already has strong structure.

Files have roles. Dependencies have shape. Changes can be compared. Branches have meaning. Merges can be reviewed. The system is not perfect, but it is legible enough to support disciplined collaboration.

Organisations usually do not have that level of structural clarity.

That is the gap.

If organisations are going to become AI-legible, they need more than storage. They need ontology.

They need a structured way to answer questions like:

  • What kinds of things exist in this organisation?
  • How do they relate?
  • Where does knowledge belong?
  • How does work connect to purpose?
  • How do decisions trace through the system?
  • What is a gap, a risk, a dependency, a capability, a contribution?
  • What should be governed, and how?

Without this, the organisation remains a tangle of partially connected fragments.

With it, the organisation can start to become teachable to both people and AI.

This is where KnowledgeFund comes in

KnowledgeFund should not be understood as just another knowledge management system.

It is not merely a place to put documents.

It is not a prettier intranet. It is not a smarter search bar. It is not a dumping ground for lessons learned.

The point of KnowledgeFund is to provide the organising ontology that makes an AI-legible organisation possible.

That means helping the organisation create structure around:

  • knowledge
  • work
  • decisions
  • purpose
  • gaps
  • capabilities
  • contributions
  • change

In that sense, KnowledgeFund is not only the store. It is the frame that makes the store meaningful.

It gives the organisation a way to place, connect, trace, and govern what it knows and what it is doing.

That is why it matters.

AI raises the stakes

This problem existed before AI, but AI raises the stakes because it increases both the value of structure and the cost of incoherence.

A fragmented organisation using AI does not become aligned by default.

It becomes faster at producing disconnected output.

A company with unclear knowledge, weak traceability, political bottlenecks, and stale context will not get rescued by better prompts. It will simply produce more convincing confusion.

That is why the next wave of advantage will not come only from who has access to the best models.

It will come from who can make their organisation legible enough for AI to help with real work in a coherent way.

What Git did for code

Git gave software teams a practical way to manage a living body of change.

It made contribution, divergence, review, integration, and history workable at scale.

It did not solve every software problem. But it created a durable structural layer that modern software development could build on.

Organisations are now facing a similar need.

They need a way to make knowledge, work, decisions, and change more legible, traceable, and governable.

They need a practical structure for collective organisational intelligence.

That is why I think this may become the real role of KnowledgeFund.

What Git did for code, KnowledgeFund may need to do for organisations.