Atlas: A Permanent Library of Engineering Knowledge

An open, human-readable knowledge system for the age of artificial intelligence

1. The Problem: AI Has Intelligence but No Portable Memory

Artificial intelligence is transforming software engineering. Modern AI models can write code, analyze architectures, generate documentation, and assist with complex design decisions.

Yet there is a fundamental problem: the knowledge accumulated while working with AI is difficult to preserve, inspect, transfer, and reuse.

Today, AI development is fragmented across numerous models, vendors, applications, and proprietary platforms. Each provides its own interface, context management, memory mechanisms, and integrations.

An engineer may spend weeks discussing a complex architecture with one AI assistant, exploring alternatives, refining requirements, and making design decisions.

What happens when the engineer switches to another model?

Much of the context must be reconstructed.

Even when conversations can be exported, they are not equivalent to a structured, reusable body of engineering knowledge.

1.1 Knowledge Is Trapped in Proprietary Systems

AI vendors maintain proprietary models and context-management systems. Some provide memory, project files, retrieval, and export capabilities, but portability between vendors remains limited.

Knowledge becomes scattered across conversations, proprietary memory stores, documents, and application-specific databases.

The user may own the ideas but lack a practical, vendor-independent representation of the accumulated design knowledge.

1.2 Switching AI Models Is Expensive

Moving to another AI model often requires explaining the project again:

  • What problem are we solving?

  • What architecture did we choose?

  • Which alternatives were rejected?

  • What assumptions are still valid?

  • Which requirements have changed?

  • What has already been implemented?

This consumes time, tokens, and computing resources.

More importantly, reconstructed context may omit subtle but important reasoning.

1.3 Knowledge Is Difficult for Humans to Review

AI conversations are chronological, but engineering knowledge is not.

A design decision may evolve through dozens of conversations. Its supporting evidence, objections, alternatives, and implementation consequences may be scattered across hundreds of messages.

Reading the entire history is inefficient. Summarizing it risks losing important details.

Traditional source code comments, README files, wikis, and issue trackers only partially solve this problem.

1.4 Repeated Context Processing Is Wasteful

Large AI context windows make it possible to process substantial amounts of information, but repeatedly loading entire conversations and documents is expensive.

A system should not need to rediscover its own architecture every time a new session begins.

Instead, it should retrieve the relevant, compact, structured knowledge needed for the current task.

We need persistent knowledge, not merely persistent conversations.

2. The Vision: Atlas Knows the Project

Imagine beginning a conversation with any capable AI model and saying:

"Atlas, load the project."

Atlas reads the project's knowledge repository, identifies its current architecture, accepted decisions, active problems, requirements, specifications, and outstanding tasks.

The engineer can immediately continue:

"Atlas, why did we choose Git as our configuration storage?"

"Architect, compare the designs of SomeModule 1.0 and 2.3."

"Atlas, process the new Inbox messages."

"Atlas, identify requirements affected by this design change."

"Atlas, show the history of this decision."

The AI does not need to remember previous conversations. It retrieves the knowledge from a permanent, structured repository.

The central principle is simple:

AI models are interchangeable. Knowledge belongs to the user.

Atlas is not another proprietary AI model. It is a proposed open knowledge architecture, supported by AI agents that can operate with different models and vendors.

The long-term goal is to make accumulated engineering knowledge independent of whichever AI happens to be used today.

3. A Library of Engineering Knowledge

Human civilization developed libraries to preserve knowledge beyond the lifetimes of individual people.

Books preserve scientific discoveries, mathematical theories, engineering methods, and historical observations.

Encyclopedias organize facts and connect related subjects.

Wikipedia demonstrates how large bodies of knowledge can be collaboratively maintained, linked, reviewed, and continuously improved.

Software engineering needs something similar.

But engineering knowledge has additional requirements.

Designs evolve. Different versions coexist. Decisions may be proposed, accepted, rejected, or superseded. Requirements depend on constraints. Implementations must satisfy specifications. Experiments may support or contradict hypotheses.

A traditional book is largely static.

Atlas proposes a library of living engineering knowledge.

It should preserve not only conclusions, but also the reasoning that produced them.

It should remember not just what was decided, but why, when, by whom, under which assumptions, and for which versions of a system.

4. Knowledge Is a Network of Nodes

The fundamental unit of Atlas is a knowledge node.

A node represents a meaningful piece of information.

Examples include:

  • Fact, Problem, Goal, Question

  • Assumption, Constraint, Regulation, Risk

  • Hypothesis, Observation, Experiment, Finding

  • Requirement, Specification, Design, Decision

  • Project, Module, Interface, Service

  • Task, Test, Release, Deployment

Each node has a stable identity, a type, metadata, human-readable content, and relationships with other nodes.

For example:

Problem: Configuration is fragmented
    |
    v
Goal: Unified configuration management
    |
    v
Requirement: Resolve effective configuration
    |
    v
Specification: Configuration resolution algorithm
    |
    v
Task: Implement configuration resolver
    |
    v
Test: Verify overlay precedence

This is not simply a collection of documents.

It is a knowledge graph.

A requirement may be connected to several problems. One architectural decision may affect multiple projects. A regulation may constrain dozens of specifications.

Relationships are as important as the nodes themselves.

Atlas should allow users to navigate from any design fact to its causes, consequences, dependencies, supporting evidence, and history.

5. Plain Text as the Universal Knowledge Format

Atlas proposes storing knowledge in compact, human-readable plain-text documents, primarily Markdown.

A node might look like this:

#id problem/configuration-fragmentation
#type problem
#template template/problem

#title Fragmented Configuration Management
#status Accepted

#motivates goal/unified-configuration
#affects project/config-service

---

Configuration is distributed across multiple
applications and deployment environments.

This makes auditing, promotion, troubleshooting,
and consistency difficult.

This representation has several advantages.

Human-readable. Engineers can understand and edit the files without specialized software.

Machine-readable. AI agents and compilers can parse structured directives and relationships.

Compact. Relevant knowledge can be retrieved without repeatedly processing long conversations.

Portable. The format does not depend on a particular AI vendor or database.

Extensible. New node types, attributes, and relationships can be introduced without redesigning the entire platform.

Version-controlled. Git provides history, branching, review, comparison, and rollback.

The format should remain simple enough that a developer can open a file in any text editor and understand its meaning.

The plain-text repository is the source of truth. Search indexes, databases, graph representations, and browser views can be generated from it.

6. Git as Permanent Knowledge Storage

Git already solves many problems associated with preserving evolving information.

It records what changed, when it changed, and who authored the change.

It supports branches, merges, collaboration, pull requests, and distributed copies.

Atlas proposes using these capabilities for design knowledge, not just source code.

A project's knowledge repository might contain:

project/
    README.md
    ExecutiveSummary.md

    docs/
        inbox/
        problems/
        goals/
        facts/
        constraints/
        requirements/
        decisions/
        specifications/
        tasks/
        experiments/
        templates/

Each file is independently readable, while Atlas interprets the repository as a connected graph.

This also eliminates the need for special session handoff documents.

A conversation is temporary. The knowledge repository is permanent.

At the beginning of a new session, Atlas loads the relevant repository state and reconstructs its working context.

The repository is the memory. The AI is the processor.

7. Knowledge Has Versions, Variants, and Effective States

Engineering knowledge is not always replaced when a new design appears.

Multiple versions of a system may exist simultaneously.

For example:

SomeModule
    |
    +-- Base Design
    |
    +-- Version 1.0.0
    |
    +-- Version 2.0.0
    |
    +-- Version 2.3.4

Version 1.0 may still run in production while version 2.3.4 is being developed.

Both designs remain valid within their respective contexts.

Atlas should support inheritance and overlays, allowing a newer design to describe only its differences from an established base.

It must also distinguish three independent dimensions:

Subject version: Which version of the software or system does this knowledge describe?

Knowledge state: Is this design proposed, accepted, effective, deprecated, or rejected?

Repository history: How has the recorded knowledge changed over time?

A user should be able to ask:

"What is the effective design of SomeModule 2.3.4?"

"What changes are proposed for version 3?"

"What was the accepted design last year?"

"Why was the authentication mechanism changed?"

This is similar to a configuration resolver, except the output is an effective knowledge graph rather than a configuration file.

8. Beyond Individual Projects

Engineering knowledge frequently crosses project boundaries.

A shared authentication service may be used by dozens of applications.

A configuration management design may influence a user preferences system.

An architectural principle may apply across an entire organization.

Atlas should support relationships between independently maintained project repositories.

For example:

Atlas Platform
    |
    +-- Config Service
    |
    +-- User Preferences Service
    |
    +-- Knowledge Compiler
    |
    +-- Shared Libraries

Each project can retain its own source files, ownership, permissions, and Git history.

Atlas can construct a unified view of their relationships without requiring all projects to be stored in one repository.

This creates the possibility of a permanent organizational engineering knowledge library.

9. One Knowledge Model, Many Workflows

Traditional engineering processes use different structures.

Waterfall emphasizes requirements, specifications, implementation, and verification.

Agile emphasizes epics, stories, tasks, iterations, and incremental delivery.

Research emphasizes questions, hypotheses, experiments, observations, and findings.

Operations emphasizes incidents, problems, root causes, fixes, and deployments.

Atlas should not force all projects into one methodology.

Instead, it can provide reusable project profiles that define preferred node types, validation rules, and workflows.

The underlying knowledge model remains the same.

A research project, an Agile software project, and a regulated engineering project can all use the same knowledge infrastructure while presenting different views.

10. Connecting Existing Engineering Systems

Today, engineering knowledge is fragmented across specialized tools.

Jira stores issues. Microsoft Planner stores tasks. Confluence stores pages. GitHub stores code and pull requests. Octopus Deploy records deployments. Other systems manage requirements, compliance, risks, and tests.

Each tool has its own data model, API, user interface, permissions, and history.

Atlas proposes a common semantic layer connecting these systems.

Specialized agents and adapters could synchronize knowledge with external applications:

                 Atlas
            Knowledge Graph
                   |
       +-----------+-----------+
       |           |           |
      Jira      Confluence    Planner
       |           |           |
     Issues       Pages       Tasks

       +-----------+-----------+
       |           |           |
     GitHub      Octopus      Wiki
       |           |           |
     PRs          Deploys     Articles

Synchronization may be one-way or two-way.

For example, Atlas may be authoritative for an architectural decision, while Octopus remains authoritative for deployment events.

The integration layer must preserve identity, provenance, permissions, and conflict-handling rules.

The goal is not necessarily to replace existing applications.

It is to prevent knowledge from becoming isolated inside them.

One knowledge representation can support many specialized interfaces and workflows.

11. The Knowledge Browser

A human-readable repository is essential, but navigating a large graph requires more than a text editor.

The proposed Knowledge Browser would display the effective state of one project or a collection of related projects.

It could provide tree views, relationship graphs, search, timelines, traceability views, and comparisons between versions.

Users could switch between accepted, proposed, effective, and historical views.

A requirement could be opened to reveal the problem that motivated it, the design that satisfies it, the tasks implementing it, and the tests verifying it.

Git history would remain available for inspecting earlier revisions.

The browser would be a projection of the knowledge graph, not another independent source of truth.

12. Atlas as an AI Knowledge Architect

Atlas is the primary AI agent responsible for maintaining and using this knowledge.

Its conversational alias is Architect.

At the beginning of a session, Atlas can load the project's README, Executive Summary, glossary, accepted architectural decisions, templates, relevant knowledge nodes, and recent Inbox entries.

It can then build an effective working graph.

Typical responsibilities include processing free-form Inbox notes, identifying new knowledge nodes, proposing relationships, detecting contradictions, generating requirements and specifications, updating existing documentation, and answering architectural questions.

Other specialized agents may later handle implementation, review, testing, deployment, publication, and external synchronization.

Human review remains essential for consequential design decisions.

Atlas should also distinguish verified facts from assumptions, hypotheses, proposals, and opinions. Preserving knowledge does not mean treating every recorded claim as true.

13. Open Source and Vendor Independence

The proposed system should be open and vendor-neutral.

Its file format, node model, relationship semantics, template system, and compilation rules should be documented and available for independent implementation.

Any capable AI model should be able to read the repository and operate on its knowledge.

A company should be able to change AI providers without losing its accumulated design history.

An engineer should be able to work offline using the text files.

A team should be able to review knowledge changes through ordinary Git pull requests.

No single AI vendor should control access to an organization's engineering memory.

Open formats and open-source implementations make this goal achievable, although practical interoperability, security, and efficient context loading will require careful engineering.

14. From Artificial Intelligence to Persistent Knowledge

Modern AI systems are increasingly capable of reasoning over large amounts of information.

But intelligence and knowledge storage are different responsibilities.

A model can reason about an architecture. A repository can preserve the architecture. A knowledge graph can connect its concepts. A compiler can reconstruct its effective state.

Atlas proposes separating these responsibilities.

Rather than repeatedly teaching an AI what a project is, we maintain a durable body of knowledge that any suitable AI can consult.

Rather than treating conversations as the record of engineering work, we extract and preserve the meaningful knowledge they produce.

Rather than scattering facts, requirements, constraints, discussions, and decisions across incompatible systems, we give them a common representation.

And rather than allowing design knowledge to disappear when people leave, projects end, or AI vendors change, we preserve it as an evolving library.

Conclusion: A Library That Remembers Why

Source code tells us how software works.

Requirements tell us what it must do.

Architectural decisions tell us why it was designed that way.

Experiments tell us what we learned.

History tells us how our understanding evolved.

Today, these pieces of knowledge are often disconnected.

Atlas proposes bringing them together into a permanent, versioned, interconnected library of engineering knowledge.

A library that preserves competing ideas, design variants, discussions, decisions, and their consequences.

A library that humans can read, Git can preserve, software can query, and AI can understand.

A library that belongs to its users rather than to any particular model or vendor.

The ultimate vision is simple: AI models will come and go. Engineering knowledge should remain.