OpCon Graph

OpCon Graph is an architecture and operating model for building knowledge graphs maintained by AI agents. It transforms unstructured information into connected facts, events, entities, sources, questions, relationships, and decisions.

LifeGraph is the first practical implementation of the architecture: a private personal knowledge system used to test OpCon Graph in a real operating context.

Useful context is usually fragmented across notes, conversations, documents, task managers, calendars, financial tools, and isolated AI sessions.

Traditional knowledge bases require constant manual organization. AI assistants can process individual requests well, but often lack durable memory, reliable provenance, and access to current operational context.

As a result:

I created OpCon Graph to make knowledge continuously usable without requiring the user to maintain its structure manually.

The user provides information naturally: a note, event, message, link, question, task, observation, or decision idea.

Specialized agents then:

The goal is not to store more information. It is to turn accumulated knowledge into a working system of memory and evidence.

OpCon Graph uses a machine-first graph model built around several principles:

Every structured record carries metadata such as identity, record type, timestamps, privacy, sensitivity, source lineage, status, and relationships.

This makes an answer inspectable: the user can see which evidence was considered, which assumptions were made, and what could change the recommendation.

OpCon Graph does not copy every connected dataset into one centralized database.

External budgeting tools, calendars, task managers, CRMs, repositories, and other systems remain independent graph nodes and sources of truth. Specialized agents retrieve only the context required for the current task.

This avoids:

Any compatible resource can potentially become a node if it exposes an API, MCP server, CLI, or another programmable interface.

OpCon Graph supports configurable advisor archetypes that analyze the same evidence through different perspectives.

An advisor can define:

The current implementation includes six advisor archetypes covering balanced analysis, asymmetric risk, antifragility, Stoic reasoning, negotiation and incentives, and AI strategy.

Advisor interpretations never become facts automatically. Their recommendations remain separate from the evidence and require user acceptance before becoming decisions.

The system does not stop at retrieving information.

When enough evidence exists, OpCon Graph converts analysis into a decision checkpoint:

A decision-sufficiency guard prevents agents from repeating analysis when no new evidence can change the outcome.

The user retains control over final decisions and consequential external actions.

The first implementation attempted to structure information too aggressively. The system began creating unnecessary organization instead of preserving the user's actual knowledge.

I temporarily reduced the workflow to raw intake, then rebuilt it around explicit record types, source lineage, confidence, and clear boundaries between facts and interpretations.

This failure shaped a central design principle:

The project began as LifeGraph, a personal knowledge system.

As reusable patterns emerged, I separated the concepts:

The current repository contains both layers, but the package boundary is now explicit. The active implementation is bound to OpCon Graph package 0.3.0 through configuration and 23 hash-pinned package files.

A PostgreSQL-backed storage path was explored as part of the architecture.

For the active personal implementation, the additional operational complexity was not justified. Local Markdown was selected as the sole active knowledge store, while PostgreSQL remains an optional storage contract in the reusable architecture.

The return to Markdown was treated as a compatibility problem rather than a simple file migration:

The return was verified against a baseline of 1,572 records and 845 domain edges.

Fourteen isolated synthetic checks covered intake, updates, typed relationships, metadata, raw immutability, invalid writes, storage routing, and package drift.

Private knowledge is local and excluded from Git.

The public repository contains only:

It does not contain personal records, credentials, private service data, or sensitive decision evidence.

The repository also enforces:

Project development history is kept outside the knowledge graph so that the graph is not polluted by its own implementation work.

OpCon Graph scales through composition rather than centralization.

New capabilities can be added as:

The shared model remains stable while individual implementations choose their own data, roles, integrations, permissions, and storage mode.

The current implementation validates architectural extensibility. It does not yet claim proven performance at millions of records or large-scale concurrent use.

Potential applications include:

The architecture is especially useful when context must persist over time, provenance matters, and existing systems must remain independent sources of truth.

A user is deciding whether a professional workshop fits their goals, available budget, and schedule.

The workshop, goal, deadline, costs, and constraints are recorded.

Output: Structured, source-linked context.

The user asks whether to attend, purchase the recording, or skip it.

Output: A decision question linked to relevant evidence.

OpCon Graph checks an external budgeting tool and calendar.

Output: Current context without copying external data.

Each option is evaluated by cost, timing, value, and reversibility.

Output: Clear and traceable trade-offs.

An antifragility advisor examines downside exposure and optionality.

Output: An interpretation that remains separate from facts.

OpCon Graph proposes an option, fallback, and review conditions.

Output: An evidence-based action with an inspectable decision trail.

The project has progressed from an experimental personal graph into a versioned implementation of a reusable agent-maintained knowledge architecture.

Current verified metrics:

Working hours, AI-token usage, development cost, and productivity improvement were not measured and should not be claimed.

OpCon Graph is a source-aware knowledge architecture for AI agents. It transforms unstructured information into connected evidence, retrieves current context from independent external resources, and supports traceable decisions through specialized agents and configurable advisors. LifeGraph is its first practical implementation.