• 

  Knowledge graph

• 

  Intelligence page

• 

  Blueprint Document

• 

  Planner

• 

  Integrations

Blueprint Society (blueSC)

Inspiration

Y Combinator recently published three requests for startups: "AI Operating System for Companies," a "Company Brain," and "Software for Agents."

These three calls converge on exactly what we had already been building.

The first two identify the same core problem — the biggest blocker to AI automation is no longer the models. It's the critical knowledge that is scattered across dozens of disconnected tools, and no product exists that connects all of that context into a single intelligence layer that can reason across it. Decisions get made, artifacts get created, context gets scattered across Slack, GitHub, Notion, Linear, docs, and people's heads — and none of it is legible to the AI systems that are supposed to help.

The third makes the complementary point: the next wave of internet users won't be people — they'll be AI agents. And those agents need software built for them as first-class citizens, not human interfaces with agent support bolted on. They need machine-readable structure, not dashboards. They need APIs and executable environments, not buttons and forms.

We built the workspace where all three converge.

The Problem

The default assumption in software engineering is that the primary bottleneck is speed of code production. The entire industry — from AI copilots to low-code platforms to component libraries — optimizes for generating code faster.

This is wrong.

The bottleneck is cognitive coherence: the ability to hold an entire system in your head, understand how every piece connects, and make decisions that account for the full context of what exists and what's been decided.

Modern software projects distribute their state across dozens of disconnected tools. Architecture lives in Miro. Requirements live in Notion. Tasks live in Linear. Code lives in GitHub. Conversations live in Slack. Decisions live in people's heads. No single human — and no current AI system — has access to the complete state of the project at any moment.

AI copilots made this worse. They generate code at unprecedented speed into systems they fundamentally don't understand. They cannot see the architecture. They don't know what was decided last month. They produce locally correct code that is systemically incoherent.

The result: teams move faster at the line-of-code level while moving slower at the system level.

The first-principles insight is simple. A software project is not a collection of files, tasks, and documents. It is a graph. Every component depends on other components. Every task relates to an architectural decision. Every decision constrains future decisions. These relationships are the actual structure of the project — and they are currently invisible to every tool in the stack.

Make those relationships explicit, machine-readable, and persistent, and you create something that has never existed: a workspace that understands the project it contains.

What It Does

Blueprint Society is a collaborative, AI-native engineering workspace that eliminates the friction between system architecture, technical documentation, and project execution. Instead of letting specifications and task boards live in disconnected silos, the platform translates project goals into a dynamic Blueprint Knowledge Network (BKN) — a typed, directed knowledge graph that maps software components, data flows, dependencies, and decisions into a persistent, machine-readable structure.

The BKN is not a visualization. It is the system of record. Everything in the workspace — the Nexus AI Copilot, the planner, the documentation editor, the proactive insights engine — reads from and writes to the same graph.

Nodes represent goals, components, tasks, patterns, and artifacts. Edges carry typed relationships: DEPENDS_ON, BLOCKS, INFORMED_BY, REQUIRES_SKILL. Every node carries a trust envelope — confidence score, source type, temporal decay, and provenance — so the AI knows not just what exists, but how much to trust it.

Backed by an autonomous agent fleet and integrated with 1,000+ third-party tools and services via Composio, the platform leverages secure, sandboxed VMs to allow AI agents to safely execute code, run tests, and verify implementations in isolated environments.

How We Built It

Frontend: Next.js with Turborepo monorepo architecture (apps/landing, apps/admin, packages/shared). The knowledge graph canvas is built on React Flow (xyflow) with a custom physics simulation layer for the interactive, force-directed layout. Nodes render as blue orbs at graph intersections — the result of significant iteration to make the graph feel like a living system rather than a static node-link diagram.

Backend & Database: Supabase with pgvector for hybrid storage — relational data for node/edge schemas, vector embeddings for semantic search. Qdrant as a dedicated vector database for high-performance similarity queries powering the GraphRAG pipeline.

AI Layer — Hybrid GraphRAG: This is where the architecture earns its weight. The retrieval pipeline combines vector similarity search (pgvector + Qdrant) with structured graph traversal. A query first identifies semantically relevant nodes via embedding similarity, then follows typed edges to pull in structurally connected context. This retrieves information that is both topically relevant and architecturally related — something pure vector search alone cannot do.

Structured Context Injection: Unlike standard RAG systems that summarize retrieved content into prose, Nexus passes structured context blocks directly to the LLM. The model receives node types, edge types, confidence scores, and relationship chains — preserving the graph topology that gets destroyed by summarization. Models reason better when they can see actual relationships, not prose descriptions of them.

LangGraph Orchestration: The extraction and synthesis pipeline is orchestrated through LangGraph, handling the multi-step process of ingesting content, extracting entities and relationships, scoring confidence, and inserting nodes into the BKN.

Relevance-Gated Traversal: Graph traversal depth is not fixed. Each hop is scored by embedding similarity to the original query. Traversal terminates when relevance drops below a dynamic threshold — preventing both context starvation (too shallow) and context pollution (too deep).

Incremental Ingestion: The BKN updates on every content-save event, not in batch. New nodes enter the graph immediately with provisional trust scores and are verified through use. The graph is always current, not periodically current.

Integrations: Composio provides bidirectional sync with 1,000+ tools — GitHub, Slack, Notion, Linear, Google Drive, and beyond. This isn't a nice-to-have. It's the difference between "another dashboard I have to check" and "the place where I actually work."

Proactive Intelligence: A background analysis layer continuously reviews the BKN for structural anomalies: disconnected subgraphs (isolated work with no dependencies), orphan nodes (tasks with no owner), stale nodes (decisions not reviewed since dependent code changed), and scope inflation (backlog growth beyond healthy thresholds). These surface as prioritized insights without requiring the user to ask.

Challenges We Ran Into

Designing the Blueprint Knowledge Network. This was the hardest problem we faced — and the one everything else depends on. We needed a graph structure that was simultaneously human-navigable on a visual canvas and machine-readable for AI reasoning, without exploding in complexity. After countless iterations, we landed on the typed node taxonomy with directional edges carrying explicit relationship types. The hybrid storage layer (PostgreSQL + Qdrant) emerged from the realization that relational integrity and vector similarity serve fundamentally different query patterns that both needed to be first-class.

Making the graph feel alive. Early versions looked like a standard node-link diagram — technically correct but useless for developing intuition about a project. Making it feel like a living system — with physics simulation, meaningful clustering, visual hierarchy that communicates project health at a glance — required significant iteration on the React Flow canvas layer.

Accomplishments We're Proud Of

The knowledge graph visualization. Seeing your entire project as a living, physics-based graph — where you can visually trace how components connect, where dependencies cluster, where isolated work is happening — is a fundamentally different experience from reading a task list. It turns project understanding from a linear, document-by-document process into spatial intuition.

Context retention across sessions. You can leave a project for a week, come back, and Nexus knows exactly where you were, what decisions were made, and what's still unresolved. No re-onboarding yourself to your own project.

Shipping a full workspace, not just a feature. The knowledge graph, planner, documentation editor, file manager, copilot, and integrations layer all work together as a unified surface. That's not a demo — that's a product.

What We Learned

The graph is the product. We started thinking of the knowledge graph as a feature. We ended up realizing it's the core primitive — everything else (the copilot, the planner, the proactive insights) is just a different way of reading and writing to the same graph. Once we understood that, the architecture simplified dramatically.

AI needs structure, not summaries. The instinct is to summarize everything into natural language before feeding it to an LLM. But models reason better when they can see the actual relationships — which node depends on which, what's blocked, what's provisional. Structured context beats prose context.

People don't want another tool — they want fewer tools. The integrations and bidirectional sync aren't nice-to-haves. They're the difference between "another dashboard I have to check" and "the place where I actually work."

What's Next

Semantic reconciliation. Automatic detection and merging of nodes that refer to the same concept under different names — reducing graph fragmentation and making context retrieval more reliable.

Agentic graph traversal. Instead of the AI receiving a fixed context window, it will be able to request additional traversals in a loop — deciding for itself when it has enough context before generating a response. The model becomes an active reader of the graph, not a passive consumer.

Beyond the screen. The BKN is a structured data layer, not a visual interface — which means it doesn't need a monitor to be useful. The same graph that powers a desktop workspace today can power contextual overlays on smart glasses tomorrow, or coordinate devices in any physical environment where context matters.

Built With

• e2b
• gemini
• langgraph
• n8n
• next.js
• pgvector
• qdrant
• react-flow
• supabase
• turborepo