-
-
Keep Every Project Surface Aligned
Inspiration
We experienced this problem firsthand while building startups.
Startups move quickly. The strategy changes, the product evolves, and the pitch deck is constantly rewritten to reflect the latest direction. A decision made in one meeting can affect the roadmap, financial model, website, product requirements, investor materials, and code.
But those changes do not naturally propagate.
Instead, teams spend hours searching through documents, updating the same information in multiple places, and trying to determine which version still reflects what the company believes. As teams become leaner and AI makes it possible to build and iterate even faster, this coordination problem becomes more severe. The company can change direction in minutes, while the artifacts surrounding it remain weeks behind.
We wanted projects to feel alive—to have a living understanding of what happened, what the team currently believes, and how each piece of work relates to that direction.
That inspired us to build North.
What it does
North is an intelligence layer that keeps a company coherent as it evolves.
It connects to the tools a team already uses—documents, presentations, meetings, email, calendars, and code—and organizes project knowledge into three layers:
- The Record: what happened, including meetings, emails, research, agreements, and historical versions.
- Direction: the decisions, assumptions, and priorities guiding the project now.
- Living Documents: the decks, plans, websites, product specifications, financial models, and code that should reflect that direction.
When something important changes, North determines what changed, which artifacts are affected, and why they may now be outdated. It then prepares grounded, reviewable updates while keeping the user in control.
For example, if a team changes its business model, North can identify conflicts in the financial plan, investor update, product roadmap, and website. If a product requirement changes, North can trace the impact into the specification, launch plan, documentation, and codebase.
North is not simply a change-detection tool. It is a shared context layer that other people and agents can act on.
How we built it
We used GPT-5.6 and Codex throughout both the product-design and development process.
GPT-5.6 helped us translate the initial idea into a structured product model, define the relationships between evidence, decisions, dependencies, and living documents, and create a detailed implementation plan.
For each development phase, a lead Codex agent coordinated a three-step workflow:
- A builder agent implemented the phase against the product plan.
- An independent reviewer inspected the code changes, ran builds and type checks, tested product states, and verified that the implementation still matched North’s underlying model.
- A fresh agent, given a specific user persona and no prior knowledge of North, tested the live experience to determine whether the problem and workflow were understandable without explanation.
GPT-5.6 also helped us communicate the product clearly. It helped shape the demo narrative, refine the story and pacing, and translate abstract ideas such as project drift and dependency propagation into visual scenes and animation concepts for the final presentation.
Within the product, North analyzes connected project information, extracts meaningful decisions, and builds an evidence-backed dependency graph between sources, direction, and living documents.
When new information enters the project, North evaluates whether it represents a meaningful change, determines what existing direction it affects, identifies related artifacts, and proposes appropriate actions.
Challenges we faced
One of the hardest challenges was identifying what had actually changed.
A sentence in a meeting transcript might represent a confirmed decision, a possibility under discussion, a temporary hypothesis, or an idea that was immediately rejected. Treating every new statement as project truth would make the system noisy and unreliable.
We addressed this by separating historical evidence from active direction. The original source remains preserved in the record, while potential decisions can be confirmed, superseded, or marked as needing review.
Another major challenge was understanding how changes should propagate. A pricing decision might affect a website, financial model, sales deck, and investor update—but not every file containing the same number. North therefore needs to understand semantic relationships and ownership, rather than relying only on keyword matching.
We also had to decide which changes were important enough to surface. Constantly notifying users about every inconsistency would create alert fatigue. The experience needed to remain quiet when nothing meaningful had happened and become visible only when action was useful.
Building and maintaining the dependency graph introduced another challenge. Repeatedly scanning every project artifact with an AI model would be slow, expensive, and unnecessary. We needed a system that could reuse existing relationships, inspect only the relevant parts of the project, and update the graph incrementally as new information appeared.
Finally, we had to balance automation with trust. North could automatically edit many parts of a project, but not every change should happen without human judgment. We designed recommendations to be grounded, explainable, editable, dismissible, and user-confirmed.
What we learned
We learned that organizational knowledge is not a single source of truth.
Different artifacts own different parts of the truth. A meeting transcript records what was said. A decision captures what the team currently believes. A pitch deck communicates that belief to investors. These should remain connected, but they should not be treated as interchangeable.
We also learned that the most valuable AI experiences may not begin with a chat box. Users should not always need to know which question to ask. A system can observe when something meaningful changes and surface the right action at the right moment.
At the same time, conversational access remains powerful once the system has reliable context. With North, a user could ask why the roadmap changed, what assumptions are still unresolved, which documents contradict the current strategy, or what happened over the past month—without manually collecting and summarizing information first.
We also learned how effective multi-agent development can become when agents have clearly separated responsibilities. Using different agents for implementation, technical review, and fresh-user testing helped us catch both engineering issues and product-design problems earlier.
What we are proud of
We are proud that North goes beyond summarizing documents or answering isolated questions.
It creates an evolving model of a project, understands how decisions connect to real work, and turns changes into concrete, reviewable actions.
Despite the complexity underneath it, the user experience remains straightforward. A user does not need to understand knowledge graphs or dependency systems. They simply see what changed, what is affected, why it matters, and what North recommends doing next.
We are also proud that North establishes a foundation for collaboration between specialized agents. Instead of giving every agent a disconnected prompt or manually written summary, North can provide the relevant project context and relationships needed for that agent to act safely.
What is next for North
The hackathon gave us enough time to demonstrate North’s core loop: understand an important change, trace its impact, and prepare grounded updates. But we see this as the foundation for something much larger.
In the near term, we want to deepen North’s integrations and make change propagation more proactive. Before a team publishes a website, presents a deck, sends an investor update, or ships a product change, North should verify that the relevant surfaces still reflect the project’s current direction.
The next step is agent coordination. North should not need to perform every action itself. Instead, it can provide specialized agents with the exact context, evidence, and constraints they need to act safely.
For example, if North detects outdated pricing on the company website, it could pass the relevant decision and codebase context to Codex, which prepares the change for review. A finance leader without coding experience could initiate and approve a straightforward correction without navigating the repository.
North could also provide reliable context whenever users work with other agents. Instead of repeatedly explaining the project’s history, decisions, and constraints, users could begin each interaction with the relevant context already assembled.
Over time, North can become the shared coherence layer for an organization—connecting people, documents, products, and specialized agents so they can all act from the same evolving understanding.
Built with
GPT-5.6 Codex OpenAI API AI Agents Large Language Models Generative AI Knowledge Graphs Semantic Search Dependency Graphs Natural Language Processing Multi-Agent Systems React TypeScript Next.js Node.js
Log in or sign up for Devpost to join the conversation.