Five layers.
One governed surface.
Harbor is structured like an operating system. Applications sit on top, the decision chain runs in the middle, governance wraps action, and the Nexus language underneath gives every agent the same shared semantics.
This page is the buyer-facing read of how Harbor is structured, not just what each agent does in isolation.
The governed chain, as a live orbit.
This is the circular system view of Harbor’s decision chain: Macro feeding regime, Sentiment feeding flow, Signal scoring conviction, Valuation anchoring price, Risk gating capital, and Execution closing the loop. It’s interactive, it’s immersive, and it belongs on Architecture.
Regime detection and structural break context.
Implemented in Harbor, but not visible in the latest stored chain scan.
From surface to substrate.
The stack reads top-down because that is how a buyer encounters Harbor first, but it reasons bottom-up in practice: foundation, governance, language, agents, then surfaces.
Dashboards, reports, and system views are where the chain becomes usable. They translate governed outputs into something an operator or buyer can actually read.
Each agent adds one kind of judgment, then passes a tighter object forward. Observation becomes scoring, scoring becomes valuation, and valuation only becomes action after governance.
Shared primitives stop every page and every agent from inventing a slightly different definition of signal, risk, position, or trade. That consistency is part of the product.
From signal to settlement.
This is the system-wide view: one shared context bus above the chain, the six agents in sequence, and the persistence, governance, and narrative surfaces underneath.
MacroCtx · SentimentCtx · SignalCtx · ValuationCtx · RiskCtx · ExecutionCtx
agent_memory · scan_digest · sleeve_ledger
PASS · BLOCK · REVIEW · approval queue
Natural-language inspection over the same chain
How data moves through the system.
The architecture only works because the same few infrastructure patterns repeat everywhere: shared context, persistent memory, governance, broker connectivity, operator surfaces, and human-readable narrative.
Shared context is the central contract. Agents do not whisper to each other directly; they publish structured context into a common surface.
Harbor persists state across scans with `agent_memory`, `scan_digest`, and `sleeve_ledger`, so later decisions have continuity instead of amnesia.
Every proposal ends in PASS, BLOCK, or REVIEW. Governance is not a decorative wrapper around the chain; it is the operating boundary around capital.
Execution reaches the market through one governed path. Routing, fills, and reconciliation all happen through the same broker bridge.
Dashboard, signal lineage, audit surfaces, and the system canvas are all applications sitting above the same chain and the same language.
Natural-language access belongs in the architecture view because it is how humans inspect reasoning, not a separate intelligence stack bolted on later.
The live visual anchor belongs here too.
You were right to call this out. Architecture should still carry a live graph view of the system so the page feels like the operating model, not just a text explanation. Nexus remains the deeper semantic breakdown, but the graph belongs on this page as a flagship system view.
Live Harbor graph
System nodes, cluster groupings, and cross-layer connections rendered from Harbor's live canvas payload.
Domain-agnostic by design.
One of the clearest buyer stories in Harbor is that the infrastructure is portable. The finance-specific logic sits on top of a much more general governed decision framework.
Multi-agent orchestration, shared context, governance, memory, approval queue, operator surfaces, and narrative inspection are not finance-specific ideas. They are the reusable core.
The chain, broker path, sleeve logic, Kelly sizing, and paper-trading runtime are the finance implementation. That is where Harbor becomes an equity operations system.
Shared language deserves its own surface.
Architecture explains the operating model. Nexus explains the nouns, links, and contracts that keep that operating model coherent. You should feel the distinction when you move between the two pages.
Go deeper on primitives, semantic topology, public language guidance, and the graph tooling that keeps Harbor inspectable.
Use the full interactive graph when you want operator topology, live node inspection, and the raw system view beyond this architecture read.
See every agent up close.
Walk the decision chain from Macro to Execution, then inspect the shared language underneath it on the Nexus surface.