Introducing SourceAtlas: Your Project's Living Knowledge Hub

As we build out our universe of collaborating agents, we create immense power and flexibility. We also create complexity. When your system is no longer a single application but a fleet of a dozen or more specialized workers, a new problem emerges: how does anyone, including you, keep a mental model of how it all fits together?

A traditional README.md file won't cut it. Static documentation is a snapshot in time, doomed to become outdated the moment you ship your next feature. In a dynamic, agent-based world, you need a dynamic, living source of truth.

Enter SourceAtlas, the brain of your project.

SourceAtlas isn't just a documentation site; it's a core part of the architecture. It's a "keeper of meaning," an agent whose entire competence is to understand your system and explain it to others. In our pantheon of agents, this is the work of Definia.

SourceAtlas: The Fleet's Source of Truth

In a production environment, SourceAtlas is a dedicated worker that acts as the central nervous system for your entire fleet. Its job is to be the "single source of fleet truth."

It does this by constantly ingesting information from every other worker in the system:

• Documentation: When you build a new agent, you also write documentation for it. SourceAtlas automatically collects this and makes it searchable in a central place.
• Health Checks: Every agent reports its health status to SourceAtlas. This provides a single, unified dashboard to see the real-time health of your entire system.
• Dependencies and Contracts: When one agent declares that it depends on another via a specific contract, SourceAtlas records that relationship.

This provides an incredible "operator-first" experience. When something goes wrong, you don't have to SSH into a dozen different places. You can simply ask SourceAtlas: "What is the health of the payment processing agent?" or "Show me all the agents that depend on the user authentication service."

graphify: Your Local Knowledge Graph

The power of a living knowledge hub isn't just for production. As a developer, you need that same power on your local machine. This is where the graphify command-line tool comes in.

graphify is your personal SourceAtlas. It's a tool that scans your entire codebase—your TypeScript files, your configuration, your documentation—and builds a local knowledge graph. This graph is a rich, queryable model of your project's architecture, dependencies, and concepts.

The development workflow in this new paradigm revolves around this tool:

• Before you code: Instead of manually searching for files, you ask questions.
• graphify explain "agent:Torria" - to get a summary of what the Torria agent does, where its code lives, and its primary competence.
• graphify path "function:A" "database:B" - to understand the exact path data takes from a function to a database table, revealing every agent and contract in between.
• While you code: You have a constant stream of questions. "What other components use this type?" or "If I change this function's signature, what will break?" The graph can answer these questions instantly.
• After you code: You've made a change. You simply run graphify update . to bring the knowledge graph up to date with your new code. In many projects, this is even automated as a pre-push git hook, so the project's collective brain is always current.

How a Knowledge Hub Changes Everything

This is more than just fancy documentation. It fundamentally changes how you develop.

Imagine you're a new developer joining the team. In a traditional project, you might spend weeks just reading code to understand the architecture. In a SourceAtlas-powered project, your first day looks like this:

1. Clone the repository.
2. Run graphify query "What is the high-level architecture?"
3. Run graphify query "What is my first task?"
4. Run graphify explain "concept:Manifest" to understand the core concepts you'll be working with.

You can become a productive contributor in hours, not weeks.

Or imagine a production bug. An error is reported in the BillingAgent. Using graphify, you can instantly see all of its upstream and downstream dependencies. You might discover that the error isn't in the BillingAgent at all, but in an incorrect data format being sent by the UserManagementAgent three steps up the chain. You can pinpoint the root cause in minutes, not days.

From Documentation to Intelligence

SourceAtlas and graphify represent the final pillar of our architecture. They are the intelligence layer that makes the entire system navigable and manageable. Without this "project brain," the complexity of a multi-agent system would quickly become overwhelming.

This is why it's an indispensable tool. It's the shift from writing documentation that nobody reads to building a queryable intelligence that understands your code as well as you do. With this, we have completed our overview of the environment. We have our workspace, we have our core libraries, and we have our project's brain.

Now, it's time to start building.