Juan Castro

Project study / Developer Tools

Active Development

Compass

A principles-first advisory architecture that preserves judgment structure while keeping providers replaceable.

Compass separates authored principles from interpretation, qualification, mediation, and execution so a future advisory runtime can preserve method without preserving a personality.

TypeScriptNode.jsJSON SchemaYAMLnpm workspaces
Repository private

System portrait / documented flow

01 / CompassPrinciples remain central while authoring, qualification, mediation, and execution form controlled layers around replaceable provider inference.

Diagram routes and groups

Durable center

  • Authored principles
  • Profile release

Judgment layers

  1. Context and intent
  2. Qualification / evidence
  3. Deterministic assembly
  4. Provider mediation

Replaceable edge

  • Provider / model inference
  • Execution / output
  1. Authoring / releaseMutable source to immutable profile release
  2. PrinciplesDurable Compass-owned layer
  3. QualificationEvidence and boundary checks
  4. Provider mediationOne replaceable provider binding
  5. Provider / modelExternal, bounded inference
  6. Execution / outputExplicit policy and non-canonical result

02 / Problem and response

Preserve principles without preserving a personality.

Constraint

Advisory systems can mistake a model's fluent personality for the durable judgment they are meant to carry, leaving principles, permissions, evidence, and uncertainty hidden inside an opaque prompt-and-response loop.

Compass treats preserved judgment as an authored, reviewable system with explicit boundaries instead of as a synthetic person or a model-owned identity.

Approach

The repository builds a deterministic path from human authoring and review through profile validation, immutable release, qualification, assembly, provider mediation, and execution contracts.

The current work stops short of claiming a finished advisory product: provider-backed execution is experimental, and the canonical repository has no UI, database, authentication, or production Engine runtime.

03 / Architecture and boundaries

Authored judgment moves through explicit gates before a replaceable provider sees it.

Principles and profile records remain the durable center. Mutable Studio material is reviewed and validated before an immutable Profile Release can become runtime input.

Qualification selects eligible evidence and records exclusions before deterministic assembly. Provider mediation binds one verified assembly to a replaceable provider definition; execution then binds that mediation to an explicit policy and request.

An in-progress adapter boundary now reaches experimental provider transport and non-canonical execution results, while the provider-neutral contracts remain protected from provider-specific leakage.

Durable core

Authored principles, profile records, validation, release identity, and provenance remain Compass-owned and inspectable.

Judgment boundaries

Context, intent, need, evidence eligibility, qualification, and assembly are explicit checkpoints rather than hidden model behavior.

Replaceable edge

Provider definitions, adapters, transport, and model selection sit outside the durable principle structure and produce non-canonical execution artifacts.

  • 01

    The model is downstream of permissions, context selection, qualification, and assembly; it is not the authority for what a profile may disclose or claim.

  • 02

    A validator-clean staged profile is not automatically released, and a consultation or execution result does not modify canonical profile knowledge.

  • 03

    The current adapter work can cross into local nondeterministic inference, but no provider SDK or model family is canonical and no public UI is presented as complete.

04 / Current state and next work

What exists, and what follows.

Active Development

The deterministic boundary is active; provider execution and any user-facing Engine remain experimental.

Started July 2026 · Last updated October 2026

Next direction

  • Continue empirical qualification, probing, and confidence calibration without hard-coding a universal threshold.
  • Harden adapter and provider execution boundaries while keeping results non-canonical and auditable.
  • Build a user-facing Engine only when its permissions, release, qualification, and reproducibility boundaries are ready to support it.

Preserving principles is a boundary-design problem before it is a model-integration problem.

Working lesson / Compass