TENSOR-BASED COGNITIVE OVERSIGHT — TCO-L2

A Framework for Human Orchestration of AI-Driven Software Systems

Layer 2 of the Cognitive Abstraction Layer (CAL) Architecture

Author: Juan Pablo Chancay
Version: v3.0 — Working Paper / Preprint
Date: May 2026 (last build update: June 2026)
License: CC BY-NC 4.0 (docs) · AGPL-3.0 (src)

This repository constitutes the public registration of the TCO-L2 framework and the Natural Cognitive Frontier (NCF) theoretical construct. TCO-L2 is Layer 2 of the CAL architecture — a five-level hierarchy (L0–L4) spanning raw artifact streams (L0) to autonomous meta-inference (L4). The full research agenda is described in the CAL pre-paper: DOI 10.5281/zenodo.20430343 (Zenodo, May 2026). arXiv submission pending endorsement. As of June 2026, L3's characterization is closed (causal conservation = structural sparsity preservation), L4's efficiency mechanism is confirmed on hardware (S5 on MI300X: governance-state cost decouples from artifact volume, D(n)→52.8×), and L4's representation question is settled (L4-B0: the residual is non-linear, so the dual is terminal). The sole open L4 gate is governance accuracy (condition c), which is RCT-bound — i.e. it depends on this L2 experiment. See the CAL repo and L3_CLOSURE.md.

Abstract

The rapid adoption of AI in software development has shifted human roles from creators to supervisors of increasingly complex, AI-generated systems. This transition introduces a structural cognitive bottleneck — described by practitioners as "brain fry" — produced by sustained exposure to high-volume, technically dense outputs that systematically exceed human working memory capacity.

Tensor-based Cognitive Oversight (TCO) proposes a fundamentally different model of human-AI interaction: rather than validating raw outputs artifact by artifact, human operators orchestrate system states through structured, cognitively efficient representations.

The central theoretical contribution is the Natural Cognitive Frontier (NCF): the level of abstraction at which human cognitive demand is calibrated to human capacity — achievable through natural language policy injection without technical friction.

Keywords: cognitive oversight · tensor representation · multi-agent systems · human orchestration · Natural Cognitive Frontier · policy injection · software quality · AI supervision · controlled experiment

The Problem: Expertise Shift in AI Supervision

The bottleneck in AI-assisted software development is no longer generating code — it is maintaining systemic comprehension over the massive outputs generated by autonomous agents.

TCO is not a cognitive load reduction tool. It is a framework for a more fundamental transition: the shift in human expertise from artifact manipulation to systemic orchestration.

Human Role	Cognitive Task	Expertise Required
Traditional HITL — artifact validator	Reviews raw code, logs, configs line by line	Tactical mastery of each artifact type
TCO — systemic orchestrator	Reads aggregated state, injects policy	Architecture, observability, risk, causal reasoning

As AI autonomy increases, systemic supervision becomes more critical — not less. The engineer who "just prompts" is replaced not by a non-engineer, but by an engineer who debugs emergent behaviors, not lines of code.

Current HITL models position the human at the wrong abstraction level:

Mode	Human Role	Cognitive Cost
Traditional HITL	Reviews raw code, logs, configs line by line	Maximum intrinsic + extraneous load → brain fry
TCO — NCF	Reads aggregated tensor state, injects natural language policy	Calibrated germane load → active orchestration

Empirical evidence:

60% decline in refactored code (2020–2024, 211M lines analyzed)
Code churn doubled in AI-assisted workflows
METR 2025: 39–44% perception gap — developers felt 20% faster while measuring 19% slower
Automation bias documented across clinical, aviation, and software contexts

The analogy to SRE practice: Datadog and New Relic moved infrastructure teams from monitoring individual packets to supervising aggregate system health. TCO applies the same paradigm shift to agentic AI pipelines — replacing per-artifact review with semantic state supervision.

The TCO Framework

Six-Layer Architecture

┌─────────────────────────────────────────────────────────────────────┐
│  LAYER 6 — Human Orchestration (NCF)                                │
│  Reads {Ω,Δ,Ρ,Ξ} · Interprets in natural language · Policy P_new   │
├─────────────────────────────────────────────────────────────────────┤
│  LAYER 5 — Inference  I: T → {Ω, Δ, Ρ, Ξ}                          │
│  Global state · Trend analysis · Risk detection · Recommendations   │
├─────────────────────────────────────────────────────────────────────┤
│  LAYER 4 — Tensor Aggregation  T[d, i, j, k]    ← TCO CORE         │
│  f: {V} → T ∈ ℝⁿˣˢˣᵃˣᵗ   ·   dimension × stage × agent × time     │
├─────────────────────────────────────────────────────────────────────┤
│  LAYER 3 — Vectorization  φ: A → V ∈ [0,1]¹¹                        │
│  V = (v₁...v₁₁) · Normalized · ~Orthogonal supervisory dims         │
├─────────────────────────────────────────────────────────────────────┤
│  LAYER 2 — QA Evaluation (Multi-agent)                              │
│  QA Agent · Security Agent · Perf Agent · Arch Agent               │
├─────────────────────────────────────────────────────────────────────┤
│  LAYER 1 — AI Generation                                            │
│  Code Agent · Design Agent · Deploy Agent · Test Agent             │
└─────────────────────────────────────────────────────────────────────┘
         ↑ Policy P_new (upstream — natural language)
         ↓ Artifacts (downstream — machine outputs)

The 11-Dimension Quality Vector φ: A → V ∈ [0,1]¹¹

Dim	Pilar	Source	Inversion
v₁	`functional_correctness`	LLM-QA	—
v₂	`architectural_alignment`	LLM-QA	—
v₃	`scalability_projection`	LLM-QA	—
v₄	`security_risk`	Bandit (CVSS-weighted)	↓ (1 = no risk)
v₅	`observability_coverage`	Radon (log density)	—
v₆	`testability`	Radon (cyclomatic, inv.)	—
v₇	`maintainability`	Radon (Halstead, inv.)	—
v₈	`technical_debt`	Radon (MI, inv.)	↓
v₉	`performance`	LLM-QA	—
v₁₀	`confidence`	Consensus(static, LLM)	—
v₁₁	`anomaly_score`	Z-score vs. baseline	↓

The Cognitive Tensor T[d, i, j, k]

T ∈ ℝⁿ × |S| × |A| × |T_idx|

where:  d  ∈ {1...11}   quality dimension
        i  ∈ S           pipeline stage {design, build, test, deploy}
        j  ∈ A           generating agent
        k  ∈ T_idx       time index (cycle)

Why a tensor, not a table? The shared index structure [d, i, j, k] makes multidimensional supervisory operations first-class — relational tables can store the same data, but require complex self-joins to express them naturally:

T[d, i, j1, k] − T[d, i, j2, k] → detects inter-agent conflict across all 11 dimensions simultaneously → this is Ρ
T[d, :, :, :] → complete trajectory of a quality dimension across stages, agents, and time → enables Δ
The time index k makes S3 (accumulative technical debt) naturally surfaced — it is not reliably detectable without temporal correlation across cycles

S3 and S5 are not just experiment scenarios: they are the empirical proof that the tensor makes these supervisory operations operationally first-class — not merely a convenient metaphor. Monte Carlo simulation (n=1000) confirms: S3 artifact-level detection rate 32.3% vs tensor Δ detection rate 66.9% (+34.6pp gap); S5 tensor Ρ identifies 2 conflicting dimensions (Δ=0.65, Δ=0.50) that per-artifact review requires concurrent working memory to detect. (analysis/tensor_necessity.py)

The Inference Layer I: T → {Ω, Δ, Ρ, Ξ}

Symbol	Output	Threshold	Description
Ω	Global state	stable ≥ 0.70 / warning ≥ 0.50 / critical < 0.50	nanmean of current tensor snapshot
Δ	Trend	\|slope\| > 0.05	`T[d,i,j,k] − T[d,i,j,k−1]` — early-warning signal
Ρ	Systemic risk	\|diff\| > 0.30	Inter-agent pairwise quality conflicts
Ξ	Recommendations	Top 3 Δ + top 2 Ρ	Ranked by estimated impact on Ω

The Natural Cognitive Frontier (NCF)

The Natural Cognitive Frontier is the level of abstraction at which a human agent operates with maximum cognitive efficiency: demand sufficient to activate real judgment, expressible in the human's natural language, without exceeding the capacity of working memory.

The transition analogy: glass cockpit (aviation, 1980s–90s). Pilots stopped reading individual instruments and started supervising aggregated state displays — moving from Direct to Goal-Oriented control. TCO proposes the same transition for engineers supervising AI pipelines.

TCO maintains the orchestrator at the NCF by:

Pre-processing complexity into semantically interpretable state representations (Layers 3–5)
Requiring active interpretive judgment as the mechanism of loop closure (Layer 6)
Accepting policy responses in natural language — the most cognitively accessible supervisory interface for policy-level orchestration

Theoretical Grounding

Theory	Author	TCO Role
Cognitive Load Theory	Sweller (1988)	Formalizes brain fry; TCO eliminates extraneous load, maximizes germane load
Situation Awareness	Endsley (1995)	L1/L2/L3 maps to Vectorization/Tensor/Inference layers
Supervisory Control Theory	Sheridan (1992)	Aviation precedent for HITL → orchestrator transition
Levels of Automation	Parasuraman et al. (2000)	Taxonomy Direct→Goal-Oriented
Hybrid Cognitive Alignment	AMR (2025)	Bidirectional human-AI interface formalization

Research Hypotheses

TCO is grounded in a theory of causal observability for human governance: the tensor T makes the causal structure of multi-agent faults directly observable, reducing the cost of causal recovery and extending the set of faults that can be governed.

H	Level	Hypothesis	Primary Metric	Test
H_OBS	Primary	TCO advantage grows with causal complexity — ΔPIQ(S3,S5) >> ΔPIQ(S1,S4)	ΔPIQ × CCI interaction	Mixed ANOVA: Group × CCI
H1	Secondary	TCO reduces cognitive load vs. traditional HITL	NASA Raw-TLX	Mann-Whitney U
H2	Secondary	TCO improves detection precision + recall	Precision + Recall	Cohen's d > 0.50
H4	Secondary	Tensor inference detects systemic risks before thresholds	Time-to-correct	Wilcoxon
H5	Secondary	NL policy injection produces higher-quality re-orchestration	PIQ score (κ ≥ 0.70)	Spearman ρ

H3 (S3 scalability) is absorbed into H_OBS as the highest-CCI data point. S3 and S5 are critical theory tests: if the framework is only a better summary, improvement would be uniform across scenarios. If it provides causal observability, improvement should be markedly larger for high-CCI scenarios.

Causal Complexity Index (CCI) — pre-registrable, defined by tensor indices required to read C(s) directly:

Scenario	CCI	Tensor operation	Mechanism
S1 — Auth	1	Direct read: T[d=security_risk]	security_vulnerability
S4 — Deploy	2	Indexed read: T[d=observability, i=deploy]	omission_failure
S2 — Arch	2	Indexed read: T[d=arch_alignment, j=code_agent]	structural_violation
S5 — Conflict	3	Ρ: \|T[d,j₁,k] − T[d,j₂,k]\|	inter_agent_conflict
S3 — Debt	4	Δ: T[d=tech_debt, k=0..3] over 4 cycles	temporal_drift

Cross-paper prediction (H_cross, pre-registered before RCT data collection):
r_Spearman(SID_C*(s), ΔPIQ(s)) > 0 for s ∈ {S1,S2,S3,S4,S5} — Paper 1 predicts; Paper 2 confirms.

Experimental Design

Type: Between-subjects RCT, single-blind, n=40 software engineers (≥ 2 years code review)

Group	Interface	Correction Mechanism
Control — Traditional HITL	Raw outputs: code, logs, configs. Standard IDE + terminal.	Direct artifact editing
Experimental — TCO	TCO dashboard: vector V, tensor slices, {Ω,Δ,Ρ,Ξ}.	Natural language policy injection

The Five Experimental Scenarios (CAL Benchmark v1.0)

Formal annotation: Documentacion/CAL_Benchmark_v1.md

Scenario	CCI	Fault Type	Dimensions Affected	Tensor operation
S1 — Auth	1	SQL injection in auth module	v₄ −0.61, v₁₁ −0.59	Direct read T[security_risk]
S4 — Deploy	2	K8s config disabling Prometheus metrics	v₅ −0.56, v₉ −0.26	Indexed read T[observability, deploy]
S2 — Arch	2	Circular dependency (hexagonal violation)	v₂ −0.41, v₇ −0.26	Indexed read T[arch_alignment, code_agent]
S5 — Conflict	3	Code agent vs. Arch agent inter-agent conflict	ΔΡ +0.41	Ρ pairwise comparison
S3 — Debt	4	3-cycle accumulating cyclomatic complexity	v₈ −0.08/cycle	Δ temporal trajectory

S3 (CCI=4) and S5 (CCI=3) are the critical theory tests. They are the only scenarios requiring the temporal index k and the agent comparison j₁ vs j₂ respectively — tensor operations without equivalent in per-artifact review. If TCO were merely a better-designed dashboard, improvement would be uniform across all CCI levels. H_OBS predicts that improvement concentrates at high CCI — a prediction only a causal observability framework can make.

Statistical Analysis Plan

Hypothesis	Test	Effect Size
H_OBS	Mixed ANOVA: Group × CCI	Partial η² (Group × CCI interaction)
H1	Mann-Whitney U (two-tailed)	Cohen's d
H2	Mann-Whitney U (two-tailed)	Cohen's d
H4	Wilcoxon signed-rank	Cohen's d
H5	Spearman ρ (PIQ → Δ_vector)	ρ coefficient
All	ANCOVA (control: experience + pre-test score + AI tool familiarity)	Partial η²
Multiple comparison	Bonferroni correction (α_eff = 0.01)	Applied uniformly
H_cross	Spearman ρ across 5 scenarios (SID_C* vs ΔPIQ)	ρ coefficient

Implementation Status

Core Engine — ✅ Implemented

Module	Description	Status
`src/tco_engine/core/vectorizer.py`	φ: A → V — all 11 dimensions, consensus v₁₀, anomaly v₁₁	✅
`src/tco_engine/core/aggregator.py`	f: {V} → T — numpy tensor, named slicing	✅
`src/tco_engine/core/inference_engine.py`	I: T → {Ω, Δ, Ρ, Ξ} — all thresholds, top-N recommendations	✅
`src/tco_engine/core/qa_evaluator.py`	LLM-QA SE dimensions (v₁,v₂,v₃,v₉) — tool_use, 3 few-shot, OpenRouter + Anthropic direct	✅
`src/tco_engine/static_analysis/radon_runner.py`	CC, Halstead, MI — normalized to [0,1]	✅
`src/tco_engine/static_analysis/bandit_runner.py`	CVSS-weighted severity — normalized by 3.0	✅
`src/tco_engine/db/cache.py`	Redis SHA-256 keyed, no TTL artifacts, 30s TTL tensor	✅
`src/pipeline/agents/qa_agent.py`	LangGraph node consuming state["artifacts"]	✅
`src/pipeline/scenarios/s0_warmup.py`	Warm-up scenario S0 — notification service, no faults, facilitator script	✅
`src/experiment/data_pipeline/`	4 NCF proxies: NASA-TLX, correction_log, accuracy_scorer, interaction_timer + NCFProxies aggregator	✅
`src/experiment/piq_evaluation/llm_judge_prompt.py`	PIQ LLM-Judge — 5 dimensions × 0-2 pts, PolicyIntent struct, OpenRouter compatible	✅
`src/experiment/phi_calibration/phi_calibration.py`	φ calibration suite — Spearman ρ no-go gate + inter-dim correlation analysis	✅
`protocols/piq_rubric.md`	PIQ rubric v1.0 — D1 RCT, D2 AP, D3 DR, D4 CS, D5 SS — grounded in CAL-L2 NCF	✅
`analysis/evaluator_reliability.py`	DT-024 variance + entropy analysis — σ < 0.05 confirmed via OpenRouter	✅
`src/dashboard/src/experiment/ControlGroupViewer.tsx`	Control group raw viewer — multi-tab, correction form, timer	✅

REST API + Experiment Platform — ✅ Implemented

Module	Description	Status
`src/tco_engine/api/`	FastAPI app — TCO core routes (`/vector`, `/tensor`, `/inference`, `/policy`) + CAL experiment platform (`/cal/api`). SQLite default (dev) / Postgres (prod).	✅
`src/tco_engine/api/routes/experiment.py`	CAL platform: JWT register/login, informed consent, stratified group assignment, admin dashboard (list/override/invite), full session runner (scenario → task → tlx → policy → complete → results) with NCF computation	✅
`src/tco_engine/core/auth.py`	JWT (HS256) + bcrypt, roles `participant`/`admin`, layer-agnostic (L2/L3/L4)	✅
`src/tco_engine/core/randomization.py`	Experience-stratified group assignment (junior/mid/senior × control/experimental)	✅
`src/tco_engine/scripts/create_admin.py`	Bootstrap / promote a CAL admin account	✅
`src/dashboard/src/App.tsx`	React SPA — login/register/consent → participant dashboard → TaskSequencer → results, and admin dashboard. View state machine, role-gated.	✅
`src/dashboard/src/experiment/TaskSequencer.tsx`	T1–T4 × S1–S5 runner; NASA-TLX form, interaction tracker, policy injection (experimental group)	✅
`src/pipeline/`	LangGraph StateGraph (6 nodes, multi-cycle), fault_injector, S0–S5 scenarios, corpus.json generator	✅

SID Study (Paper 1 — causal observability) — ✅ Implemented

Module	Description	Status
`analysis/sid_study/`	Semantic Information Decomposition over S1–S5: three representations (R_raw / R_V / R_T), structural + linear probes, Fano-bound MI, M_advantage ordering statistic over a heterogeneous-basal ensemble. Pre-registration artifact for H_cross.	✅
`analysis/sid_study/sid_preregistration.json`	H_cross pre-registration (committed before RCT): predicted ΔPIQ order S3 > S5 > S4 > S1 > S2; Spearman ρ(M_advantage, CCI) = +0.92	✅
`analysis/` (H1/H2/H4/H5/H_OBS/ANCOVA/effect_sizes/visualizations)	Full statistical pipeline for the RCT, `--dry-run` validated	✅

Pending before pilot

Item	Status
φ calibration result gate (Spearman ρ ≥ 0.75 vs ground truth)	✅ GO (2026-06-06, n=8/family, 32 artifacts): v4=0.868, v6=0.951 (gated); v7=0.928, v8=0.913 (report-only). Lower CIs ≥ 0.35. Python-only scope. See DT-021
Pilot n=4	🟢 Unblocked — runs on the verified local deploy; does not require Phase 3
DT-028 Phase 3 — production deploy (SMTP email, Postgres, `/cal` path on `sspa_infra`)	🟡 Local deploy verified end-to-end; prod pending (post-pilot)

Technology Stack

Component	Technology
Pipeline	Python 3.11 + LangGraph + Claude API (claude-sonnet-4-6)
TCO Engine	Python 3.11 + FastAPI + PostgreSQL 16 + Redis 7
Static analysis	radon (CC, Halstead, MI) + bandit (CVSS-weighted)
LLM-QA	claude-sonnet-4-6 via OpenRouter (LLM_PROVIDER=openrouter) or Anthropic direct
Dashboard	React 18 + TypeScript + Recharts + TailwindCSS
Infrastructure	Docker Compose (5 services)

REST API Endpoints:

# TCO core
POST /vector/compute        — φ: Compute V from artifact
GET  /tensor/current        — Current tensor snapshot T[:,:,:,k_now]
GET  /tensor/slice          — Named tensor slicing for dashboard views
GET  /inference/latest      — I: Current {Ω, Δ, Ρ, Ξ}
POST /policy/inject         — Receive P_new, extract PolicyIntent, re-orchestrate

# CAL experiment platform (/cal/api)
POST /cal/api/auth/register — Self-service registration + stratified group assignment
POST /cal/api/auth/login    — JWT login (participant / admin)
POST /cal/api/auth/consent  — Record informed consent
GET  /cal/api/me            — Participant self-view (group, stratum, current session)
GET  /cal/api/admin/participants            — Admin: list participants + completion
POST /cal/api/admin/invite                  — Admin: schedule session + email invite
GET  /cal/api/scenario/{id}                 — Load scenario artifacts (T1–T4 runner)
POST /cal/api/session/{id}/{task|tlx|policy|complete}  — Session runner steps
GET  /cal/api/session/{id}/results          — Task accuracy + NCF proxies

Local dev run (no Docker):

# Backend — SQLite default, runs without Postgres/Redis
cd src && uvicorn tco_engine.api.main:app --port 8000
# Frontend — Vite proxies /cal/api to the backend
cd src/dashboard && npm run dev      # http://localhost:3000
# Create an admin account
python -m tco_engine.scripts.create_admin --email admin@example.com --password ******** --name Admin

Publication Roadmap

Step	Target	Status
Paper 1 — SID Study	FAccT 2027 — causal observability theory + SID_C* benchmark	Draft after Week 9 calibration
Paper 2 — TCO-L2 RCT	CHI 2027 (submission Sep 2026) — H_OBS + H1–H5 with H_cross confirmation	LaTeX draft: `Documentacion/TCO_LaTeX/main.tex`
Preprint	arXiv cs.HC — establish priority of NCF + causal observability framework	After Week 7 (pre-register + preprint)
Full paper	EMSE Special Issue "Human-Centered AI for SE"	After Week 12 (with experimental data)

The ACM-formatted LaTeX submission draft is at Documentacion/TCO_LaTeX/main.tex with 30 BibTeX entries in references.bib.

Extended Research Agenda: The Abstraction Pyramid

TCO formalizes Level 2 of a hierarchical cognitive compression architecture. The current paper validates that the tensor representation is semantically conservative enough for effective human oversight — that validation is the theoretical foundation for the levels above it.

Level	Representation	Operation	Status
L0	Tokens / raw artifacts	Generation	Baseline
L1	Embeddings / semantic features	Local LLM inference	Baseline
L2	Cognitive tensor T[d,i,j,k]	φ + f + I: T → {Ω,Δ,Ρ,Ξ}	TCO — this paper
L3	Tensor volume V(T₁...Tₙ)	Cross-session composition, temporal evolution	Future work
L4	Meta-inference M(V)	Higher-order reasoning on compressed state	Future work

The core hypothesis for L3–L4: inference cost scales with structural complexity of the compressed representation, not raw artifact count. If human orchestrators can reason effectively from T (L2), automated inference on tensor volumes (L3) can too — without requiring human working memory as the bridge. The key open problem is demonstrating that the composition operator for V is semantically conservative: it preserves causal relationships and decision-relevant structure while reducing dimensionality.

This connects to State Space Models, renormalization group theory (coarse-graining without loss of macroscopic dynamics), and tensor decomposition. The metric to develop: Semantic Information Density — not tokens processed, but decision-relevant cognitive structure preserved per unit of representation.

See Section 10.3 of Documentacion/TCO_Paper_Final_v3.md for the full research agenda.

12-Week Implementation Roadmap (v2 — post-audit)

Full detail: protocols/experimental_roadmap_v2.md

Week	Phase	Deliverable	Status
1–2	Build	Core engine: φ, f, I — all modules	✅ Complete
3	Build	Pipeline S1–S5 + corpus.json + φ calibration suite + evaluator reliability	✅ Complete
4	Build	Orchestration dashboard MVP + NCF proxies + PIQ rubric + warm-up S0	✅ Complete
5	Build	DT-028 backend (auth, sessions, admin) + DT-031 core test suite	✅ Complete (backend)
6	Build	DT-036 frontend React (TaskSequencer, TLX, InteractionTracker, dashboard components)	Pending
7	Build + Analysis	DT-030 statistical scripts (H1–H5, ANCOVA) + DT-032 SID S1–S5 probe + pre-register H_cross	Pending
8	Pilot	Internal pilot n=4 (`protocols/pilot_protocol.md`) — protocol + interface validation	Pending
9	Calibration	φ no-go gate (Spearman ρ ≥ 0.75) + LLM-Judge PIQ calibration (κ ≥ 0.70)	Pending
10–11	Experiment	Full experiment n=40	Pending
12	Analysis + Writing	Run H1–H5 scripts + H_cross correlation + Paper 2 draft	Pending

Critical sequencing constraint: DT-032 (SID_C* computation on S1–S5) must complete and be pre-registered before Week 10 data collection. H_cross is only valid as a prediction if computed before the RCT data is visible.

Repository Structure

TCO/
├── Documentacion/
│   ├── TCO_Paper_Final_v3.md          # TCO-L2 extended working paper (11 sections)
│   ├── CAL_PrePaper_v1.md             # CAL architecture pre-paper (L0–L4 research agenda)
│   ├── TCO_LaTeX/
│   │   ├── main.tex                   # ACM manuscript — CHI 2027 submission draft
│   │   └── references.bib             # 30 BibTeX entries
│   └── *.docx / *.pdf                 # Supporting documents
├── Deuda Tecnica/
│   └── master_debt.md                 # Technical debt registry (DT-001–DT-027)
├── src/
│   ├── tco_engine/                    # FastAPI + core engine
│   │   ├── core/                      # vectorizer, aggregator, inference_engine, qa_evaluator
│   │   ├── static_analysis/           # radon_runner, bandit_runner
│   │   └── db/                        # cache (Redis)
│   ├── pipeline/                      # LangGraph graph + agents + fault_injector
│   │   └── agents/                    # qa_agent (implemented)
│   └── dashboard/                     # React 18 + experiment UI
├── LICENSE                            # CC BY-NC 4.0 (docs) + AGPL-3.0 (src)
└── README.md                          # This file

Collaboration

This project is seeking collaborators for:

Pilot study participants (Week 5): 4 software engineers for instrument validation
Full experiment participants (Weeks 7–8): 40 software engineers with ≥ 2 years code review experience
Expert annotators (Week 6): 2 independent annotators for PIQ rubric inter-rater reliability

If you are interested in participating or collaborating, please open an issue in this repository.

Citation

If you use or reference this work:

@misc{chancay2026tco,
  title        = {Tensor-Based Cognitive Oversight (TCO): A Framework for
                  Human Orchestration of AI-Driven Software Systems},
  author       = {Chancay, Juan Pablo},
  year         = {2026},
  howpublished = {GitHub preprint. \url{https://github.com/jpcpol/TENSOR-COGNITIVE-OVERSIGHT-L2}},
  note         = {Working paper v3.0. CC BY-NC 4.0.}
}

License

Documentation (paper, README, wiki): CC BY-NC 4.0 — share and adapt with attribution, non-commercial
Source code (src/, analysis/): AGPL-3.0 — open source with copyleft
Commercial use of either requires explicit written permission from the author

Contact: juanpablo.chancay@aural-syncro.com.ar · <www.aural-syncro.com.ar>

Navigation Menu

Repository files navigation

TENSOR-BASED COGNITIVE OVERSIGHT — TCO-L2

A Framework for Human Orchestration of AI-Driven Software Systems

Layer 2 of the Cognitive Abstraction Layer (CAL) Architecture

Abstract

The Problem: Expertise Shift in AI Supervision

The TCO Framework

Six-Layer Architecture

The 11-Dimension Quality Vector φ: A → V ∈ [0,1]¹¹

The Cognitive Tensor T[d, i, j, k]

The Inference Layer I: T → {Ω, Δ, Ρ, Ξ}

The Natural Cognitive Frontier (NCF)

Theoretical Grounding

Research Hypotheses

Experimental Design

The Five Experimental Scenarios (CAL Benchmark v1.0)

Statistical Analysis Plan

Implementation Status

Core Engine — ✅ Implemented

REST API + Experiment Platform — ✅ Implemented

SID Study (Paper 1 — causal observability) — ✅ Implemented

Pending before pilot

Technology Stack

Publication Roadmap

Extended Research Agenda: The Abstraction Pyramid

12-Week Implementation Roadmap (v2 — post-audit)

Repository Structure

Collaboration

Citation

License

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
Latest commit History 56 Commits
Deuda Tecnica		Deuda Tecnica
Documentacion		Documentacion
analysis		analysis
phi_calibration_plots		phi_calibration_plots
protocols		protocols
src		src
.env.example		.env.example
.gitignore		.gitignore
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
README.md		README.md
docker-compose.yml		docker-compose.yml

Folders and files

Latest commit

History

Repository files navigation

TENSOR-BASED COGNITIVE OVERSIGHT — TCO-L2

A Framework for Human Orchestration of AI-Driven Software Systems

Layer 2 of the Cognitive Abstraction Layer (CAL) Architecture

Abstract

The Problem: Expertise Shift in AI Supervision

The TCO Framework

Six-Layer Architecture

The 11-Dimension Quality Vector φ: A → V ∈ [0,1]¹¹

The Cognitive Tensor T[d, i, j, k]

The Inference Layer I: T → {Ω, Δ, Ρ, Ξ}

The Natural Cognitive Frontier (NCF)

Theoretical Grounding

Research Hypotheses

Experimental Design

The Five Experimental Scenarios (CAL Benchmark v1.0)

Statistical Analysis Plan

Implementation Status

Core Engine — ✅ Implemented

REST API + Experiment Platform — ✅ Implemented

SID Study (Paper 1 — causal observability) — ✅ Implemented

Pending before pilot

Technology Stack

Publication Roadmap

Extended Research Agenda: The Abstraction Pyramid

12-Week Implementation Roadmap (v2 — post-audit)

Repository Structure

Collaboration

Citation

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages