The connective tissue of the Unified Cognitive Architecture

Codito, ergo sum.

Codito is the experimental reference workspace for the connective tissue of Entif AI’s Unified Cognitive Architecture.

Rosetta preserves what an artifact means and where it came from. Bilqis investigates whether explicit meaning can be made cheaper to learn. GNOSIS makes dependencies and reusable computation explicit. Akasha preserves admitted persistent state. OMoC recruits the capabilities a task actually needs. Guard controls admission to consequential effects. Swarm Gnosis moves useful cognition across participants. IndraNet gives those participants a relational fabric.

Codito asks what has to exist between those systems so they compose into one inspectable cognitive episode instead of a pile of clever subsystems passing prose to one another.

Correspondence into coherence

The project uses a simple phrase for its metacognitive job:

Codito converts correspondence into coherence.

That does not mean flattening every representation into one ontology. It means making relationships navigable enough that the system can tell which things are equivalent, related, contradictory, dependent, stale, reusable, missing, or outside the current conceptual vocabulary.

A correction should be able to find the procedures and projections that depended on it. A repeated expensive transformation should become a candidate for cheaper reuse. A task should be able to activate only the cognitive machinery required by its present dependency frontier. A novel observation should be able to say, in effect, “none of my current types fit this” instead of being forced into the nearest familiar bucket.

A metacognitive atlas

Codito treats successful cognition, failure, disagreement, counterexamples, corrections, and near misses as information about the architecture itself.

The resulting atlas can record or help expose:

  • semantic distinctions the current ontology is missing;
  • dependencies among concepts, evidence, procedures, and effects;
  • which operators are qualified for which kinds of work;
  • which expensive transformations recur often enough to deserve compilation;
  • which results remain valid after an upstream change;
  • where context can be reused and where it must be rebuilt;
  • which unresolved novelty still justifies stronger cognition;
  • and which disagreements are factual, semantic, criterial, or authority-based rather than merely “low confidence.”

The atlas is not a second truth system. Its durable identities and interoperable artifacts remain subordinate to the applicable Rosetta authority.

The orchestration surface

Codito studies a cognitive episode as an explicit graph rather than a serial prompt ritual:

source / observation
        ↓
qualified semantic state
        ↓
context compilation
        ↓
capability decomposition + dependency graph
        ↓
heterogeneous cognitive operators
        ↓
validated state deltas
        ↓
integration / commitment / guarded effect
        ↓
evaluation, memory, correction, reuse

The graph may contain deterministic code, bounded decision models, local learned functions, specialist models, frontier generative systems, tools, simulators, or humans. The research question is not which one should “be the AI.” It is which mechanism is warranted for this operation, under this evidence, rights, cost, latency, and consequence boundary.

What Codito does not own

Rosetta owns official semantic and data-bearing interoperability contracts. Codito does not mint Rosetta Core meaning by implementing a candidate shape or writing a test around it.

Codito may prototype:

  • dependency-aware execution;
  • context and experience compilation;
  • OMoC-style operator composition;
  • salience and attention surfaces such as SÍ SÉ SON;
  • progressive determinization and reusable cognitive capital;
  • correction and invalidation propagation;
  • commitment/effect boundaries;
  • integration with Akasha, Swarm Gnosis, IndraNet, and Mission Control.

Those experiments can inform later Rosetta Packs, Profiles, schemas, or governance work only through the normal authority process.

Current status

Codito is research software. The current executable baseline is a finite demonstrative model extracted from earlier ETR-2026-12 production work. The current conceptual framing follows the v0.5.8 Unified Cognitive Architecture; that does not imply the reference code was regenerated wholesale from the new manuscript.

The baseline contains 55 deterministic unit tests with no runtime dependencies beyond Python 3.10 or newer. They cover:

  • independent value, evidence, and admission change propagation;
  • fail-closed serving context and expiry behavior;
  • effect-state transitions and ambiguous replay;
  • inheritance loss and evidence genealogy;
  • bounded collection completeness and correction closure;
  • scoped query witnesses for bounded absence;
  • coherent recovery cuts and tamper detection;
  • intent-bound idempotency and stale-executor fencing.

A passing test establishes only the property exercised by that test. It does not establish production safety, benchmark savings, model-learning efficacy, distributed consistency, or Rosetta conformance.

Evaluate the work

Inspect Codito on GitHub for the executable reference models, candidate contracts, research notes, Rosetta ownership crosswalk, and bounded interoperability probes.