Lore: Bringing Deterministic Truth to the AI Coding Revolution

In the rapidly evolving landscape of generative AI, software engineers are increasingly relying on AI coding assistants—like Claude Code, Cursor, and various MCP-compatible agents—to accelerate development. However, these tools suffer from a fundamental flaw: they are "forgetful" or prone to "hallucinating" architectural decisions that have already been discarded by human teams. Enter Lore, a new project built on the Requirements as Code (RAC) engine, which promises to transform how coding agents interact with corporate knowledge. By replacing fuzzy, non-deterministic retrieval with a hard, read-only system of record, Lore aims to ensure that AI agents stop repeating past mistakes and start adhering to the exact, current specifications of the teams they serve.

Main Facts: The End of "Guessing" in AI Development

The core value proposition of Lore is simple yet profound: it treats project documentation as typed, validated code. Unlike traditional RAG (Retrieval-Augmented Generation) systems, which rely on semantic search and vector embeddings to find "similar" information, Lore provides a deterministic interface.

When a developer integrates Lore with an AI agent, the agent doesn’t "search" for a decision; it "queries" the source of truth. If a team has decided to use PostgreSQL over MongoDB, that decision is stored as a typed Markdown artifact in the repository. The agent accesses this via the Model Context Protocol (MCP). Because the retrieval is deterministic, the agent is effectively "grounded" in the team’s specific history. If an agent suggests a path that violates a previous decision, the system is designed to reject or correct that behavior before it manifests in the codebase.

Key features of the Lore ecosystem include:

• Deterministic Retrieval: No more probabilistic guessing or fuzzy matches.
• Read-Only Authority: Lore serves as a source of truth that agents cannot arbitrarily alter, ensuring the integrity of the design documentation.
• CI/CD Enforcement: Through commands like rac gate, developers can enforce that all code changes comply with the documented requirements and decisions, effectively turning documentation into a testable suite.
• Agent-Agnosticism: While it works seamlessly with Claude Code and Cursor, the underlying RAC engine is designed to be compatible with any tool that supports the MCP standard.

Chronology: From Concept to Open-Source Reality

The development of Lore is rooted in a growing frustration among senior engineers regarding the "drift" between architectural intent and implementation.

• Early Phase (The RAC Experiment): The project began under the umbrella of "Requirements as Code," an initiative to apply the rigor of software versioning to project management artifacts. Initial experiments focused on whether documentation could be "compiled" in a way similar to source code.
• Refinement of the Engine: As the engine matured, the team realized that routing and runtime decisions were distinct from static knowledge. This led to the spin-off of Wayfinder, a tool specifically for prompt-complexity routing, allowing the core RAC engine to focus strictly on knowledge management.
• Integration with MCP: With the release of the Model Context Protocol (MCP) by Anthropic, the team saw an opportunity to bring their deterministic engine directly into the IDE. The development of the rac mcp server allowed for the "Lore" brand to emerge as the primary user-facing interface for this technology.
• The Modern Era: Today, Lore exists as a robust CLI and server package, supporting complex workflows like importing existing Confluence or Notion documents, exporting data into Open Knowledge Format (OKF) bundles, and providing a Python API for custom automation.

Supporting Data: Why Determinism Outperforms Fuzziness

To understand why Lore represents a paradigm shift, one must look at the limitations of current AI memory architectures. In a standard RAG-based agent, a request for "caching strategy" might return a mix of current decisions, deprecated ideas, and outdated brainstorming notes. The LLM then has to "guess" which piece of information is the active one.

By moving away from similarity-ranked results, Lore allows agents to operate with higher confidence. When an agent is asked to build a new feature, it doesn’t just "recall" a similar previous feature; it checks the "Gate" to ensure the new implementation satisfies the existing requirements defined in the rac/ directory.

Official Responses: Bridging the Gap Between OKF and RAC

One of the most common questions regarding Lore is how it relates to Google’s Open Knowledge Format (OKF). The maintainers of Lore have clarified that there is no competition between the two.

According to the project’s documentation, OKF provides the "carrier"—the standard way to represent knowledge in a Git repository using Markdown and YAML front matter. However, OKF is intentionally permissive. Lore builds upon this foundation by adding "write-time enforcement." While OKF defines the format, RAC defines the rules of engagement.

The ability to run rac export --okf ensures that users are never locked into the Lore ecosystem. If a team decides to migrate, they can export their entire repository into a standard-compliant OKF bundle, ensuring that their intellectual property remains portable and accessible to other tools.

Implications: The Future of AI-Assisted Architecture

The implications of Lore for the software industry are significant. We are moving toward a future where "Software Engineering" increasingly looks like "Software Architecture."

1. The Death of Tribal Knowledge

In many organizations, critical architectural decisions live only in the minds of senior engineers or in ephemeral Slack threads. Lore forces these decisions into the codebase. Because the agent can "read" these decisions, new team members—and AI agents—are brought up to speed instantly with the full context of why certain technical choices were made.

2. Guardrails for Autonomous Agents

As we move toward more autonomous coding agents, the risk of "runaway code" increases. If an agent is given the power to refactor a system, it needs a "Constitution" to guide it. Lore provides that constitution. By grounding the agent in the rac/ directory, organizations can ensure that the AI respects the boundaries of the system, such as security constraints, performance requirements, and technology stacks.

3. Documentation as a First-Class Citizen

Historically, developers have viewed documentation as an afterthought—a chore to be completed after the code is written. Lore flips this dynamic. By making documentation a required part of the CI/CD pipeline (via rac gate), the project treats the reasoning behind the code with as much importance as the code itself.

4. Technical Debt Mitigation

A major driver of technical debt is the "implementation of the wrong solution." By ensuring that agents can access the current and authorized approach, Lore prevents the re-implementation of legacy patterns that the team has explicitly ruled out. This effectively acts as a filter against the entropy that usually plagues growing codebases.

Getting Started: A New Workflow for Developers

For those looking to adopt this, the entry barrier is relatively low. The system is designed to be additive:

1. Install: Use pip install rac-core to gain access to the CLI.
2. Scaffold: Use rac quickstart to establish an identity and create the first artifact.
3. Connect: Link the agent via claude mcp add lore -- rac mcp to enable the agent to query the repo.
4. Enforce: Add rac gate to the CI pipeline.

As Lore continues to evolve, the project is actively seeking contributors and experiments to refine its "skills" system—modules that allow the agent to perform specific tasks like ingesting existing documents or auditing repository health.

Conclusion

Lore is not just a tool; it is a philosophy. It posits that if we want AI to act as a competent, senior-level engineer, we must provide it with the same source of truth that we provide our human colleagues. By replacing the probabilistic "guessing" of traditional LLM architectures with the deterministic "knowledge" of the RAC engine, Lore creates a stable foundation for the future of software development. In an era where AI can write code in seconds, the ability to ensure that code is correct, compliant, and grounded in the team’s long-term vision has never been more vital. Lore provides that grounding, turning the chaos of generative AI into the precision of software engineering.