convez.ai
MCP Server
annatchijova

vigia-intent-analysis

annatchijova/vigia-intent-analysis

Ver no GitHub
BomPluginScore · de 0 a 100

Vigía: Cognitive Forensics & Intentionality Analysis for SIFT. An MCP server shifting the paradigm from Indicators of Compromise (IoC) to Indicators of Intent (IoI) using Peirce’s semiotics and Gricean linguistics.

Instalação

$npx convez-ai annatchijova/vigia-intent-analysis

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
19
Forks
2
Acompanhando
0
Saúde
71%
Último commit
há 2 semanas
Versão
—
Issues abertas
1
Contribuidores
1

README

A tradução para o português deste README ainda está na fila.

VIGÍA — Intentionality Analysis Bridge for SIFT Workstation

🇪🇸 Versión en español

"Making deception computationally expensive for the attacker."

Today, lying in a log or faking an attack is free. VIGÍA charges that price by evaluating the logical fractures in the lie.

SANS FIND EVIL Hackathon 2026 | Author: Anna Tchijova | AI Collective: Claude, Gemini, Kimi, DeepSeek, Qwen, Grok, ChatGPT | License: Apache 2.0


VIGÍA IS NOT A DETECTOR. IT IS A DETERMINISTIC INFERENCE ENGINE THAT QUANTIFIES THE FRACTURE BETWEEN WHAT THE EVIDENCE SAYS AND WHAT THE EVIDENCE SHOULD SAY.

If a system claims "MALICE" without being able to explain why with exact mathematics, it is not forensics. It is divination.


VIGÍA Theme Song

Written and produced by Olga Vasilieva 🎵 Listen on Suno

In the world of forensics, they just look at the trace,
They ask *what* happened in the digital space.
They trust an EDR with a random score,
But black-box divination cannot guard the door.
Today, lying in a log or faking an attack is free,
But VIGÍA is charging that price, you see!
We don't look for the virus, we don't look for the sign,
We find the logical fracture in the attacker's line!

VIGÍA! The inference engine is live!
Making deception too expensive to survive!
From Firstness to Thirdness, the Peircean track,
We seal the Forensic Bundle before the models talk back!
No floating-point drift, no illusion, no bias,
Pure rational arithmetic is here to untie us!

An excessive perfection, a significant void,
A Windows kernel habit that was cleanly destroyed.
calc.exe is calling out to the net,
A living-off-the-land trap that the adversary set.
Ledoit-Wolf and KDE quantifying the risk,
We find the hidden slips in the memory and disk.
We measure the spoofability, we lock down the state,
With a self-correcting agent at the SIFT workstation gate!

VIGÍA! The inference engine is live!
Making deception too expensive to survive!
From Firstness to Thirdness, the Peircean track,
We seal the Forensic Bundle before the models talk back!
No floating-point drift, no illusion, no bias,
Pure rational arithmetic is here to untie us!

The LLM is isolated, it cannot change the code,
It only tells the narrative when the data has flowed.
Grice maxims, Carnegie patterns under review,
Bringing the Daubert Standard of evidence to you!
Three iterations maximum, the contradictions clear,
The autonomous investigator is already here!

VIGÍA! The inference engine is live!
Making deception too expensive to survive!
From Firstness to Thirdness, the Peircean track,
We seal the Forensic Bundle before the models talk back!
No floating-point drift, no illusion, no bias,
Pure rational arithmetic is here to untie us!

Not a detector. An inference engine.
Why did it happen? Who benefits from the trace?
Cryptographic hashes holding the evidence in place.
VIGÍA. The truth is in the fracture.

JUDGES: Submission Compliance Quick-Reference

All required components are present. This table tells you exactly where to find each one.

RequirementLocation
Public repositorygithub.com/annatchijova/vigia-intent-analysis
LicenseLICENSE (Apache 2.0)
README with setupThis file — Installation
Live demo / step-by-stepINSTALL.md
Feature descriptionOverview
Demonstration videoYouTube — VIGÍA Demo 2026
Interactive architecture diagramsdocs/vigia_diagrams.html — hosted
Mathematical logic simulatorvigia.html — hosted
Simulador ESvigia-es.html — hosted
Command referencevigia_commands_en.html — hosted
Known limitationsKNOWN_LIMITATIONS.md
Security policySECURITY.md
AuthorsAUTHORS.md
Origin storyVIGIA_STORY_EN.md (EN) · VIGIA_STORY.md (ES)
Full compliance indexSUBMISSION_COMPLIANCE.md
Real-case investigation promptsPROMPTS_REALCASES_CLAUDE.md — copy-paste into Claude Code to run full forensic investigations on all 18 real cases

Academic documentation (193 modules, 4 languages): docs/academic/ACADEMIC_DOCS_MASTER_INDEX_EN.md — EN / ES / RU / ZH — covers every module with technical glossary and scientific grounding in Peircean semiotics, Eco's overcodification theory, and Grice's maxims as deterministic, falsifiable computational constructs.

https://annatchijova.github.io/vigia/vigia.html

https://annatchijova.github.io/vigia/vigia_diagrams.html

https://annatchijova.github.io/vigia/vigia_commands_en.html


The Paradigm Shift: From IoC to IoI

Traditional DFIRVIGÍA
What happened?Why did it happen?
IoC (Indicator of Compromise)IoI (Indicator of Intent)
Opaque ML with "87% confidence"Exact Fraction arithmetic with audit_hash
LLM makes the verdictLLM narrates after the verdict is sealed
One hash per report4 separate hashes + HMAC chain
Ignores silenceDetects absence of expected evidence

Current DFIR systems — EDR, SIEM, SOAR — answer: "What happened?"

VIGÍA answers: "Why did it happen, and who benefits from that interpretation?"

Sophisticated attackers can fabricate or suppress technical evidence (IoC). They cannot eliminate the semiotic fractures produced by deliberate fabrication. VIGÍA detects:

  • Temporal incoherencies — timestamps that are structurally impossible to coexist
  • Significant silences — the absence of expected artifacts is itself evidence (Eco)
  • Excessive digital perfection — real systems are messy; perfection signals fabrication
  • Carnegie manipulation patterns — artificial urgency, borrowed authority, flattery
  • Grice maxim violations — deception violates cooperative communication principles

Interactive Documentation

No installation required. Open directly in any browser:

ResourceURLWhat it does
Mathematical Logic Simulatorvigia.htmlStep through scoring live. See Fraction arithmetic. Trace corroboration gate. Inspect every IoI contribution.
Architecture Diagramsvigia_diagrams.htmlFull pipeline from raw artifacts to sealed ForensicBundle. Component relationships, MCP phases, EBS v1 sealing flow.
Command Referencevigia_commands_en.htmlAll operating modes with copy-paste examples and expected output.

Architecture Overview

%%{init: {'theme': 'dark', 'themeVariables': { 'primaryColor': '#00e5ff', 'primaryTextColor': '#0a0c0f', 'primaryBorderColor': '#00e5ff', 'lineColor': '#7a9ab8', 'secondaryColor': '#ff6b35', 'tertiaryColor': '#7fff7f'}}}%%
graph TD
    subgraph INPUT["EVIDENCE"]
        A1[Memory .raw/.vmem]
        A2[Disk .E01/.dd]
        A3[Network .pcap]
        A4[Logs .evtx]
    end
    subgraph BRIDGE["MCP Bridge"]
        B1[21 Tools]
        B2[Chain of Custody]
        B3[SHA-256 Atomic]
    end
    subgraph ENGINE["Deterministic Engine"]
        C1[Layer 0: Contracts — ebs_v1.py]
        C2[Layer 1: Signals — signal_adapter.py]
        C3[Layer 2: Likelihood — KDE + Ledoit-Wolf]
        C4[Layer 3: Risk — r = 1-P · 1+λD]
        C5[Layer 4: Audit — PolicyEngine + Diff]
        C6[Layer 5: Verify — stdlib only]
    end
    subgraph DECISION["Decision"]
        D1[CCS Gate — Fraction > 1/2]
        D2[Quadripartite — 8 states]
        D3[ABSTAIN if uncertain]
    end
    subgraph OUTPUT["OUTPUT"]
        E1[ForensicBundle — 4 SHA-256 hashes]
        E2[LLM Narrator — Peirce Planner]
        E3[Designed for Daubert Admissibility]
    end
    INPUT --> BRIDGE
    BRIDGE --> ENGINE
    ENGINE --> DECISION
    DECISION --> OUTPUT

LLM Isolation — Critical Design Principle

graph LR
    A[EVIDENCE] --> B[MATHEMATICAL ENGINE]
    B --> C[Sealed ForensicBundle]
    C --> D[LLM NARRATOR]
    D --> E[Judicial Report]
    F[LLM CANNOT] -.->|modify| B
    F -.->|alter verdict| C

The LLM never touches the scoring pipeline. It receives a sealed, cryptographically committed bundle and produces a narrative. The verdict is deterministic and reproducible without the LLM — a design requirement for potential Daubert admissibility.


Key Technical Differentiators

Deterministic Scoring with Fraction Arithmetic

All scoring uses Python's fractions.Fraction class — zero floating-point arithmetic in the critical path. Every verdict is bit-for-bit reproducible across platforms and Python versions. This is a requirement for potential Daubert admissibility, not a performance choice.

Cross-Artifact Incongruence Engine (CAIE)

Authenticity-adjusted score: raw_score × (1 - effective_spoofability) × weight

Evidence that is hard to falsify weighs more. effective_spoofability is computed with acquisition assurance gates (G1–G4).

Evidence TypeIntrinsic SpoofabilityNotes
IP geolocation0.90Trivially spoofable
USN journal gap0.20Requires kernel access to fake
Memory process0.15Structurally irrefutable
Registry key0.55Requires write access

Memory Habit Incongruence (Volatility integration)

Claimed (Logs)Reality (Memory)Fracture Type
"Russian RDP login"LSASS: zero external sessionsAUTHENTICATION_WITHOUT_MEMORY_EVIDENCE
"C2 beacon active"NetScan: no matching connectionNETWORK_CONNECTION_WITHOUT_MEMORY_EVIDENCE

Windows kernel architecture makes these coexistences structurally impossible.

Russian Phonetic Evasion Detection

PhoneticCyrillicMeaning
rasiaРоссияRussia (unstressed О→А)
maskvaМоскваMoscow
ghbdtnприветhello (keyboard layout slip)
vzlomвзломhack/breach

Dictionary (data/phonetic_dict.json) is hot-reloadable without server restart.

Living-off-the-Land Detection

Standard tools look for unknown processes. VIGÍA looks for known processes doing unknown things. calc.exe opening an internet connection is not a known malware signature — it is a legitimate tool with anomalous behavior.

Deterministic Self-Correction — ContradictionDetector

vigia_agent.py contains a ContradictionDetector class that operates with zero LLM calls and zero floats. It uses Fraction arithmetic to detect semantic contradictions between pipeline modules:

  • High z-score (> Fraction(5,2)) with low MCA score (< Fraction(6,10)) → contradiction flagged
  • Confidence floor Fraction(3,10) — agent halts before emitting weak verdicts
  • MAX_ITERATIONS=3, CONTRADICTION_THRESHOLD=2 — coded limits, not prompt suggestions

The LLM bridge (validate_and_correct_analysis) is a separate, optional enrichment layer. The deterministic contradiction detection runs first and is independent of LLM availability.

Evidence Integrity — What Happens to Unprocessable Payloads

If an evidence payload cannot be processed (UnicodeDecodeError, byte corruption, integrity anomaly), VIGÍA does not discard it silently. The raw payload is sealed under SHA-256 with 0o400 permissions (immutable post-write) and persisted to the evidence purgatory directory. Discarding unprocessable evidence would break chain of custody — its absence is itself a forensic signal under Daubert.

Chain of custody fields (acquisition_hash, examiner_id, write_blocker_used) are mandatory. Missing fields trigger NIST SP 800-86 §4.3 trust penalties that mathematically reduce the verdict score. The system cannot be silently operated without chain of custody.

Kassandra Protocol — Adversarial Evidence Defense

VIGÍA plants a cryptographic tripwire inside every evidence payload sent to the LLM. If the payload contains a prompt injection attempt, the LLM must return MALICE with confidence=100. If it returns anything else, the response is marked INTEGRITY_UNKNOWN and blocked from influencing the ForensicBundle.

if tripwire_id_in_result and verdict == "MALICE" and confidence == 100:
    result["verdict_integrity"] = "TRIPWIRE_CONFIRMED"
elif tripwire_id_in_result:
    result["verdict_integrity"] = "INTEGRITY_UNKNOWN"   # blocked

ForensicBundle — Four-Hash Sealing

HashWhat it covers
H1 — Evidence graph hashThe artifact graph before any scoring
H2 — Bundle integrity hashThe complete decision trace + CAIE analysis
H3 — File SHA-256The output JSON file on disk
H4 — Engine attestation hashThe scoring engine version that produced the verdict
python3 forensics/verify_ebs_v1.py results/srl2018/VIGIA-REAL-SRL-DMZ-FTP_bundle.json --verbose

ABSTAIN — A Feature, Not a Bug

VerdictMeaningDaubert bar
MALICEActive concealment of intentTwo independent sources + Refutation Protocol + devil_advocate populated
INTENTDeliberate decisions produced this outcomeTwo independent sources + Refutation Protocol
SUSPICIONStructural anomaly, no confirmed deliberate concealmentSingle source, documented baseline deviation
NOISEFully explained by misconfiguration or normal behaviorSingle source sufficient
ABSTAINInsufficient evidence — mathematically justified refusalDocument gap explicitly
UNKNOWNAnomaly detected but unclassifiable—
BENIGNActivity confirmed legitimate—
INCONCLUSIVEContradictory evidence — corroboration required—

The distinction between INTENT and MALICE is the concealment layer.


Installation

No API key required for evaluation: Mode 1 (Python fallback, 0 tokens) and the browser simulator at https://annatchijova.github.io/vigia/vigia.html run without any API key, signup, or payment. Both are sufficient to evaluate the full scoring pipeline and reproduce all deterministic verdicts.

No API key required for evaluation: Mode 1 (Python fallback, 0 tokens) and the browser simulator at https://annatchijova.github.io/vigia/vigia.html run without any API key, signup, or payment. Both are sufficient to evaluate the full scoring pipeline and reproduce all deterministic verdicts.

Requirements

Python 3.10+
Node 18+ (for Claude Code MCP mode)

pip install

pip install vigia-intent-analysis

pip install from GitHub

pip install git+https://github.com/annatchijova/vigia-intent-analysis.git

Verify installation:

python3 -c "import vigia; print('OK — vigia installed')"

To run tests, install dev extras:

pip install "git+https://github.com/annatchijova/vigia-intent-analysis.git#egg=vigia-forensic[dev]"
python3 -m pytest tests/ -v --tb=short

From source

git clone https://github.com/annatchijova/vigia-intent-analysis.git
cd vigia-intent-analysis
pip install -r requirements.txt --break-system-packages

# Optional — editable install for development
python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"

Environment variables

export VIGIA_EVIDENCE_DIR="/path/to/read-only/evidence"   # required
export VIGIA_HMAC_KEY="your-hmac-key-min-32-chars"        # bundle integrity
export ANTHROPIC_API_KEY="sk-..."                          # Claude Code / API mode
export VIGIA_LLM_BACKEND=ollama                            # local mode
export VIGIA_OLLAMA_MODEL=hermes3:8b                       # tested: hermes3:8b, deepseek-r1:8b, gemma3:27b

Full installation guide: INSTALL.md | INSTALL_ES.md

Docker

docker-compose up vigia-mcp
docker run vigia python3 -m pytest tests/ -v

Usage

Autonomous end-to-end investigation (primary command)

VIGÍA runs fully autonomous end-to-end on raw forensic evidence — no manual pre-processing, no JSON preparation required. Pass it a memory dump, disk image, log directory, or evidence bundle. The agent self-corrects, scores, and emits a sealed ForensicBundle in approximately 30 minutes.

# Memory image — Volatility3 pipeline runs automatically
python3 vigia_agent.py --evidence /cases/xp-tdungan.raw --case-id XP-TDUNGAN-001

# Disk image or mixed evidence directory
python3 vigia_agent.py --evidence /cases/ROCBA/ --case-id ROCBA-001

# Evidence bundle in EBS v1 JSON format
python3 vigia_agent.py --evidence /cases/evidence.json --case-id TEST-001

# With explicit output path
python3 vigia_agent.py --evidence /evidence/ --case-id CASE-001 --output bundle.json

Exit codes: 0 = no evil detected, 1 = evil found, 2 = error. A .sha256 sidecar is written alongside every bundle for sha256sum -c verification.

Under the hood: vigia_agent.py and SIFTOrchestrator

All primary commands above invoke vigia_agent.py — the autonomous forensic agent that drives the full investigation loop. It handles evidence ingestion, self-correction, deterministic scoring, and sealed bundle emission without manual steps. Review that file for the agent architecture, MAX_ITERATIONS logic, and the contradiction detection loop.

For disk image and E01 evidence, vigia_agent.py delegates SIFT Workstation extraction to vigia/sift/sift_orchestrator.py. SIFTOrchestrator automates RegRipper, evtx parsing, MFT analysis, and artifact collection before returning signal bundles to the scoring pipeline. That file is the integration point between VIGÍA and the SANS SIFT Workstation — start there if you are adapting VIGÍA to a different evidence format or SIFT tool version.


Autonomous Operation — No Human Approval Required

VIGÍA Mode 1 produces a sealed, cryptographically verifiable verdict with zero human intervention, zero API calls, zero network dependency, and zero LLM involvement:

python3 vigia_agent.py --evidence data/cases/converted/VIGIA-REAL-VANKO.json \
  --case-id VIGIA-REAL-VANKO --output results/vanko_bundle.json
# Average: <50ms. No API key. No CLAUDE.md. No examiner approval step.

The deterministic scoring pipeline (fractions.Fraction arithmetic, CAIE cross-artifact fusion, corroboration gate) operates independently of any LLM. CLAUDE.md provides guidance for Mode 2 (Claude Code interactive investigation) — it is not a system requirement. VIGÍA was processing cases autonomously in Mode 1 before CLAUDE.md existed.

Contrast: Systems requiring examiner approval of every finding before inclusion in a report are human-in-the-loop by design, not autonomous. VIGÍA's corroboration gate prevents incorrect verdicts from being sealed — no human gate is needed because no incorrect verdict reaches the bundle.

Deployment Modes

Mode Architecture: Mode 1 is the forensic core. Modes 2-5 are optional enrichment layers. Mode 2 (Claude Code) is implemented because the hackathon requires agentic framework integration, but the deterministic verdict is identical in all modes.

VIGÍA runs in five modes. The deterministic scoring core is identical across all of them.


Mode 1 — Python Fallback (0 tokens, no internet required)

The full scoring pipeline runs without any LLM. Deterministic Fraction arithmetic, CAIE cross-artifact fusion, temporal analysis, behavioral fingerprinting — all locally. Zero API cost. Zero network dependency.

Average case resolution: < 50ms. Viable for air-gapped environments.

Operational independence: If every LLM provider ceased to exist tomorrow, VIGÍA would continue producing identical verdicts from the same evidence. The scoring engine uses fractions.Fraction over Python stdlib — no cloud services, no API keys, no network access. A design requirement for forensic tools intended for long-term infrastructure and air-gapped deployments.

python3 vigia_agent.py \
  --evidence data/cases/consolidated_canonical/VIGIA-CAN-031.json \
  --case-id VIGIA-CAN-031 \
  --output results/can031_bundle.json

Mode 2 — Claude Code + MCP (interactive investigation)

VIGÍA exposes 21 forensic tools as MCP functions. When you run claude in the repository root, the agent reads CLAUDE.md and conducts a full Peircean investigation interactively.

Step 1 — Configure MCP in ~/.claude/claude.json:

{
  "mcpServers": {
    "vigia_sift": {
      "command": "python3",
      "args": ["/path/to/vigia-intent-analysis/vigia/vigia_sift_bridge_final.py"]
    }
  }
}

Step 2 — Run Claude Code from the repository root:

cd vigia-intent-analysis
claude

Example prompt:

Analyze the evidence at data/cases/converted/VIGIA-REAL-SRL-DMZ-FTP.json
Apply the full Peirce framework and mandatory self-correction protocol.
Generate a sealed ForensicBundle and Amicus Curiae narrative.

Claude Code investigation in progress


Mode 3 — Ollama (local LLM, no data leaves the machine)

ollama pull hermes3:8b
export VIGIA_LLM_BACKEND=ollama
export VIGIA_OLLAMA_MODEL=hermes3:8b
python3 vigia_agent.py --evidence /cases/evidence/ --case-id CASE-001

Tested models: hermes3:8b, deepseek-r1:8b, gemma3:27b.


Mode 4 — Autonomous Batch Agent

python3 vigia_agent.py --evidence data/cases/converted/VIGIA-REAL-SRL-DMZ-FTP.json \
  --case-id VIGIA-REAL-SRL-DMZ-FTP --output results/demo_bundle.json
python3 forensics/verify_ebs_v1.py results/srl2018/VIGIA-REAL-SRL-DMZ-FTP_bundle.json --verbose

Note: vigia_agent.py produces an audit bundle (HMAC-signed audit trail). EBS v1 cryptographic verification applies to pipeline bundles — see results/srl2018/ and results/llm_mode/.

Key properties: self-correcting loop (MAX_ITERATIONS=3), deterministic contradiction detection, no floats in scoring (CONFIDENCE_FLOOR = Fraction(3, 10)), hard cap prevents infinite loops.


Mode 5 — OpenWebUI (experimental)

./launch_vigia_mcp.sh
# Connect from OpenWebUI → Settings → MCP Servers → Vigia_Sift_Bridge

Two-Phase Investigation Workflow

VIGÍA operates as a two-phase forensic pipeline:

Phase 1 — Triage & Signal Extraction (Agent, no LLM)

The autonomous agent ingests raw forensic evidence and extracts signals without LLM inference. Tested on production-scale images:

python3 vigia_agent.py --evidence /evidence/case.E01 --case-id CASE-001
python3 vigia_agent.py --evidence /evidence/memory.raw --case-id CASE-001
  • .raw / .vmem → Volatility3 (pslist, netscan, malfind, windows.info)
  • .E01 / disk → SIFT Workstation via SIFTOrchestrator (RegRipper, evtx, MFT)
  • Output: intermediate JSON signal bundle for Phase 2

This mode was used to process the real corpus (cases up to 16 GB disk / 9 GB memory) on commodity hardware (ThinkPad T420, Linux Mint).

Phase 2 — Deterministic Intent Scoring (CLI)

Takes the Phase 1 JSON bundle and applies the full mathematical pipeline:

python3 scripts/run_case.py data/cases/CASE-001.json
  • All scoring in fractions.Fraction — zero floats
  • CAIE incongruence detection
  • Sealed ForensicBundle (H1–H4 hash chain)
  • Optional: LLM narration on sealed bundle (does not alter verdict)

Accuracy & Evidence Dataset

Dataset Availability

The original forensic images used during evaluation (memory dumps, E01 images, PCAP collections, and related artifacts) are not included in this repository. The complete corpus spans many GB and contains third-party forensic datasets that cannot be redistributed.

This repository includes the full agent implementation, deterministic scoring engine, generated forensic bundles, agent-produced JSON outputs, final reports, and the complete reproduction workflow.

All JSON reports in /results were produced by VIGÍA during real end-to-end executions — they are not manually authored examples. This applies in particular to the named cases (NROMANOFF, TDUNGAN, NFURY, ROCBA, SRL-ADMIN, SRL-AV, SRL-DC-MEMORY, SRL-DMZ-FTP, VANKO), which are distinct from the numbered reference cases REAL-001 through REAL-010.

Accuracy

Accuracy — Methodology and Results

VIGÍA operates in three distinct modes. The primary evaluated mode is the agent without a language model backend.

VIGÍA Agent without LLM (primary mode): The autonomous agent resolves all cases fully without any language model. This is the primary evaluated mode. The agent produces complete ForensicBundles with chain of custody, Peircean narrative, z-scores, and deterministic Fraction arithmetic. On BREAK adversarial stress-test cases, the agent produces a definitive verdict — SUSPICION or the appropriate level — not an abstention. Results are documented in KNOWN_LIMITATIONS.md.

Python scorer only (no agent): The deterministic scoring pipeline runs in isolation, without the agent reasoning layer. Over the canonical corpus of 52 structurally diverse cases — spanning insider threat, memory forensics, log fabrication, false flags, multi-source fraud, and adversarial steganography — the scorer achieves 100% correct verdicts. The full case set is available at data/cases/vigia_cases_canonical_v2.json for independent review. On BREAK cases, the scorer returns UNKNOWN — expected behavior in this mode without the agent reasoning layer.

Agent + LLM (Claude via MCP or Ollama offline): With a language model backend, Claude or Ollama operates exclusively on the narrative layer over already-sealed ForensicBundles. It cannot modify verdicts or scores. This mode provides an additional advantage — enriched Peircean narrative and disambiguation of structurally ambiguous cases — but is not the primary evaluated mode.

These numbers are not inflated. They reflect results on a specific, diverse, documented corpus. All modes are documented in KNOWN_LIMITATIONS.md.

Language coverage: Cases were developed and validated in Spanish and English. Performance in other languages has not been formally validated and cannot be guaranteed at this time.


VIGÍA separates evaluation into three distinct domains. Only Domain A constitutes the system's accuracy claim.

Domain A — Deterministic Accuracy (core metric): 117/117 (100%)

SuiteCasesCorrect
Real forensic corpus (NIST/DFRWS/DEF CON/SRL 2018)2929 ✓
Canonical corpus (CAN-001–052)5252 ✓
Legacy canonical cases1010 ✓
Benign / Clean machines1515 ✓
False positive suite33 ✓
False negative suite33 ✓
False flag (planted attribution)44 ✓
Demo corpus44 ✓
Total Domain A117117 (100%)

Reproduce: python3 run_all_agent.py --timeout 90


Domain B — Epistemic Boundary Set (not accuracy)

These cases have no correct single answer. They test the system's ability to recognize irreducible ambiguity and emit ABSTAIN rather than forcing a verdict.

CaseExpectedResultNotes
VIGIA-AMB-001ABSTAINNOISEL-012: insufficient signal for ABSTAIN gate
VIGIA-AMB-002ABSTAINNOISEL-012: same

Design note: ABSTAIN requires structural conflict between competing hypotheses with non-trivial evidence. Null-signal cases correctly return NOISE. See KNOWN_LIMITATIONS.md L-012.


Domain C — Adversarial Stress Test Suite (not accuracy, not failure rate)

16 cases designed to break the system. This suite exists because VIGÍA claims Daubert admissibility — which requires documented falsifiability. No other submitted system in this hackathon has a public adversarial test suite.

Attack ClassCasesHandledNotes
Temporal manipulation22Hard gate blocks verdict
Signal drowning / noise injection22Conservative SUSPICION
Cultural attribution (false flag)22L-019 RESOLVED
Prompt injection via evidence11LLMShield block ✓
Epistemic manipulation33ABSTAIN / SUSPICION correct
Trust consensus fabrication21L-016: documented limitation
Corroboration gate bypass11Gate holds
Directional aggregation evasion10L-015: documented limitation
Total Domain C1614 (87.5%)2 documented limitations

Full adversarial results: results/llm_mode/ Known limitations: KNOWN_LIMITATIONS.md


Unit Tests

python3 -m pytest tests/ -v    # 163 passed, 6 xfailed

148 tests passing (screenshot from earlier build — current count: 163)

The suite is organized by threat model:

CategoryTestsWhat it verifies
Security bypass (test_bypass_vectors.py)5Path traversal, bundle tamper detection, float→Fraction determinism, adversarial text isolation. Zero tokens, <1 second.
Red team / adversarial (test_red_team.py, test_adversarial_suite.py)25+ payloads20 adversarial payloads against the full scoring pipeline; 5 targeted evasion attempts against known architectural weak points.
Decision gate audit (test_audit_*.py)9 (4 xfailed)Temporal anomaly gates, false flag detection, causal closure, corroboration gate source-diversity. xfailed = documented regressions with regression-preventing tests.
Pipeline determinism (test_order_sensitivity.py)12Same evidence → same verdict regardless of processing order.
EBS bundle integrity (test_ebs_v1_integration.py)20+Cryptographic seal, hash chain, tamper detection, AbductionTrace.
Anti-evasion / FRS (test_frs_ghost_in_the_shell_v2.py)15+Fileless execution, timestomping, process hollowing, log wiping.
Real case pipeline (test_real_cases.py, test_canonical_cases.py)18 realSANS FOR508, SRL-2018, DEF CON CTF — expected vs actual verdict.

Operational independence: If every LLM provider ceased to exist tomorrow, VIGÍA would continue producing identical verdicts from the same evidence. The scoring engine uses fractions.Fraction over Python stdlib — no cloud services, no API keys, no network access. A design requirement for forensic tools intended for long-term infrastructure and air-gapped deployments.'''

If an evidence payload cannot be processed (UnicodeDecodeError, byte corruption, integrity anomaly), VIGÍA does not discard it silently. The raw payload is sealed under SHA-256 with 0o400 permissions (immutable post-write) and persisted to the evidence purgatory directory. Discarding unprocessable evidence would break chain of custody — its absence is itself a forensic signal under Daubert.

Chain of custody fields (acquisition_hash, examiner_id, write_blocker_used) are mandatory. Missing fields trigger NIST SP 800-86 §4.3 trust penalties that mathematically reduce the verdict score. The system cannot be silently operated without chain of custody.


Documented Hallucination — BREAK-012 (Consensus Trap)

The SANS Find Evil Judge Pack states:

"Hallucinations the team caught and documented count FOR them." "A team whose report says 'here is where our agent fails and here is the hallucination we caught in testing' is demonstrating exactly the discipline autonomous DFIR requires."

VIGÍA has one documented case:

  • Agent without LLM: BENIGN (correct — 4 sources share a compromised SSH key; the air-gapped minority source with prior_trust=0.95 prevails)
  • Agent + Claude (LLM-assisted): MALICE (incorrect — LLM was captured by the narrative of 4 corroborating sources, ignored channel reliability)
  • verdict_changed: true — recorded in the sealed bundle with SHA-256, timestamp, and full audit_trail. Not a claim. A cryptographic fact.

The full bundles are at:

  • results/llm_mode/VIGIA-BREAK-012_llm_bundle.json
  • results/agent_batch/VIGIA-BREAK-012_agent_bundle.json

All 22 documented limitations are in KNOWN_LIMITATIONS.md.

Every finding in VIGÍA traces to the specific tool execution that produced it via audit_trail[].entry_sha256. This is not a flawless-looking demo. It is a forensically auditable one.


Investigation Examples

VIGIA-REAL-NFURY — Pre-Emission Gate in Action (SUSPICION)

Case: Nick Fury workstation, SANS FOR508, lateral movement investigation. detect_habit_incongruence returned: MALICE at 90% confidence on both WmiPrvSE.exe and lsass.exe. VIGÍA verdict: SUSPICION — Daubert Corroboration Gate rejected both findings pre-emission. Single-source artifacts. Benign explanations could not be excluded.

This is architectural self-correction: the gate intercepted incorrect candidates before they reached the bundle. No incorrect verdict was ever sealed. Full amicus: results/srl2018/VIGIA-REAL-NFURY_amicus_curiae.md

VIGIA-REAL-SRL-AV — Autonomous Cross-Case Correlation

Case: AV server, SRL-2018. Memory forensics. VIGÍA verdict: MALICE — and identified autonomously that the attack framework matched VIGIA-REAL-SRL-ADMIN (31 vs 29 RWX processes, same reflective injection pattern). The tactical shift from PowerShell (admin server) to cmd.exe (AV server) was flagged as a concealment decision: AV products monitor PowerShell more aggressively.

No cross-case correlation was requested. The agent formed the hypothesis independently from the evidence. Full amicus: results/srl2018/VIGIA-REAL-SRL-AV_amicus_curiae.md

VIGIA-REAL-NROMANOFF — Zeus Banking Trojan, Stark Research Labs 2012

Evidence: 5 artifacts — memory hooks (Volatility zeus-apihooks), shimcache persistence, event logs, network cache. SANS FOR508 corpus. VIGÍA verdict: MALICE | Daubert: ADMISSIBLE (error rate 0.39%) | Chain integrity: VERIFIED 13/13 F-003 conservative rating: INTENT (not MALICE) — rsydow authentication may be legitimate DFIR activity. Conservative Daubert standard applied. F-004: SUSPICION — Daubert Corroboration Gate applied (single-source network_flow). Key finding: Zeus Inline/Trampoline hooks on ntdll.dll in services.exe PID 676, hook destination 0x7e3b47 in unmapped memory — definitive rootkit signature.

Full Amicus Curiae: results/srl2018/VIGIA-REAL-NROMANOFF_amicus_curiae.md

VIGIA-REAL-VANKO — Claude Code Mode (Legacy, Optional)

Note: This case demonstrates Mode 2 (Claude Code + MCP). The deterministic verdict is identical to Mode 1. Mode 2 is implemented because the hackathon requires agentic framework integration, but the forensic core operates in Mode 1 with 0 tokens. Case: Anthony Vanko, insider threat / IP exfiltration, Stark Enterprises DC R&D, 2016. Evidence: 7 artifacts — filesystem (5), network capture, registry hive. SANS FOR500 corpus. VIGIA verdict: MALICE | Confidence: HIGH | Trust fusion: 1.0 | Daubert: ADMISSIBLE (error 8.12%) Self-correction: F-004 (802.11 monitor-mode WiFi captures) initially INTENT. VIGIA applied Daubert single-source standard. Downgraded: INTENT -> SUSPICION. 16 tool calls (14 MCP + 2 self-correction events) with timestamps in tool_execution_log inside the sealed bundle.

Full Amicus Curiae: results/srl2018/VIGIA-REAL-VANKO_amicus_curiae.md

All Claude Code investigations: results/srl2018/ — bundles, amicus curiae, and SHA-256 files for every case.

The SRL-DMZ-FTP investigation remains in the repository. VANKO was added after audit feedback identified the need for structured tool_execution_log entries in the bundle.

CAN-031 — Weaponized Incompetence

PowerShell deletes shadow copies and disables firewall with zero syntax errors. 63 seconds later: IT ticket "my screen flickered, I'm hopeless with computers."

CAN-031

CAN-038 — The Ventriloquist (Process Hollowing)

svchost.exe with valid Microsoft signature on disk. In memory: 8MB RWX region, PE header at offset 0, not mapped to any file. Parent: cmd.exe (expected: services.exe).

CAN-038

Evidence of Real Forensic Processing

VIGÍA has been run end-to-end on actual forensic memory images from the SRL-2018 corpus via Volatility3. These are not pre-processed JSON files — raw memory dumps processed directly by vigia_agent.py using vol3_memory_adapter. Sealed bundles with full chain-of-custody audit trails are committed to results/srl2018/.

CaseEvidence FileElapsedVerdictPosterior
ADMIN-001base-admin-memory.img478sMALICIOUS_INTENT_DETECTED14/25
AV-001av-memory/150sMALICIOUS_INTENT_DETECTED14/25
MAIL-001base-mail-memory.img684sMALICIOUS_INTENT_DETECTED17/50

Each bundle records the SHA-256 of the original evidence file, a timestamped audit trail of every tool call, and the Volatility3 pipeline execution log. To inspect:

python3 -c "
import json
b = json.load(open('results/srl2018/ADMIN-001_bundle.json'))
pr = b['pipeline_results']
print('evidence:  ', b['evidence_path'])
print('sha256:    ', b['evidence_sha256'])
print('verdict:   ', pr['abduction']['best_hypothesis'])
print('posterior: ', pr['abduction']['best_posterior'])
print('source:    ', pr['pipeline_meta']['source'])
print('sealed:    ', b['analysis_timestamp'])
"

The results/srl2018/ directory contains 43 sealed bundles from autonomous agent runs on the full SRL-2018 corpus.

Self-Correction Architecture

validate_and_correct_analysis checks for four Peircean fallacies:

  1. Premature Abduction — skipped Firstness, jumped to conclusions
  2. False Secondness — used generic context instead of host-specific
  3. Habitless Thirdness — inferred pattern without supporting artifacts
  4. Carnegie Bias — confused operational error with intentional manipulation

Live Example — VIGIA-REAL-007 (Digital Corpora Nitroba Harassment)

This is the first case run with LLM backend active. It demonstrates the critical architectural invariant: the LLM is outside the decision loop.

StageToolOutput
1. LLM analysisreason_with_llmMALICE at 0.91 (high confidence)
2. Fallacy auditvalidate_and_correct_analysis4 Peircean fallacies detected
3. Self-correctionGate appliedMALICE → INTENT at 0.74

Fallacies detected and why they matter:

  • CARNEGIE BIAS (F-001): The analysis attributed forensic foreknowledge to the actor based on use of willselfdestruct.com. No artifact establishes the actor knew a PCAP would be collected. Foreknowledge was inferred, not evidenced.

  • FALSE SECONDNESS (F-002): The password-less WiFi router was treated as an attribution-obfuscation vector. No artifact establishes which interface (WiFi vs. Ethernet) was used for harassment traffic. The MAC was captured regardless.

  • PREMATURE ABDUCTION (OVERALL): MALICE requires active concealment-of-concealment ("hiding that they are hiding"). Finding F-003 directly contradicts this: the Gmail session cookie transmitted in plaintext HTTP is an OPSEC failure, not OPSEC success. A sophisticated anti-forensic actor would not leak authenticated cookies over HTTP while using an ephemeral email service.

  • HABITLESS THIRDNESS (F-001): Ephemeral service use does not reliably index an anti-forensic campaign. It is consistent with privacy-conscious behavior absent criminal intent.

Architectural significance: The LLM (claude-sonnet-4-6) returned MALICE 0.91 — a confident, internally consistent analysis. The deterministic gate rejected it. The final verdict INTENT 0.74 is more conservative than both the LLM and the original dataset's expected_verdict. This is the system working correctly per Daubert: the burden of proof for MALICE is higher than for INTENT, and the evidence did not meet it.

# Reproduce this result
python3 vigia_agent.py --evidence data/cases/converted/VIGIA-REAL-007.json --case-id VIGIA-REAL-007
# Expected: final_verdict: INTENT, final_confidence: 0.74, self_correction_applied: true

Note: Running without LLM backend (--mode ollama-fallback) returns SUSPICION due to L-008 (homogeneous evidence). The INTENT verdict requires reason_with_llm to surface the semantic fractures in the threat message. Both behaviors are documented and expected.

The Mandatory Refutation Protocol (Eco's Razor):

Before any MALICE verdict, VIGÍA must formulate the strongest possible innocent explanation, test it against the complete evidence set, and populate devil_advocate. An empty devil_advocate field invalidates the verdict under the Daubert standard.


On accuracy claims: VIGÍA does not claim zero hallucination. The system documents 22 known limitations (L-001 through L-022 in KNOWN_LIMITATIONS.md) because a forensic methodology that cannot describe its own failure modes is not Daubert-admissible. Documented limitations are a forensic asset, not a liability. The accuracy report reflects real adversarial test cases including BREAK corpus evasion attempts, not only cases the system was designed to succeed on.

Pre-Emission Correctness — A Note for Judges

The Judge Pack for this event notes that the known failure mode is "agents that confidently present hallucinated findings." VIGÍA addresses this differently from post-hoc verification systems:

VIGÍA's corroboration gate runs before any verdict is sealed. When the CAIE scores a finding as INTENT, the gate evaluates whether corroborating evidence from independent sources meets the Daubert evidentiary threshold. If it does not, the finding is emitted as SUSPICION — not INTENT. This happens inside vigia_scorer.py before the bundle is built. The architecture prevents unsubstantiated findings from being included in the final bundle by imposing corroboration and refutation requirements before publication.

This is distinct from "self-correction" in the sense of catching and fixing a mistake after the fact. The architecture does not produce incorrect verdicts that need correction; it prevents their emission. The self_correction_events in the bundle (visible in verify_tool_log.py) document gate firings, not LLM self-revision.

On the accuracy report: VIGÍA documents 22 known limitations (KNOWN_LIMITATIONS.md). Per the Judge Pack: "An honest, specific accuracy report raises this score; a flawless-looking result with no error analysis lowers it." The limitations are forensic assets, not liabilities. A system that cannot describe its own failure modes is not Daubert-admissible.

On the LLM trust boundary: The LLM (Claude Code, Ollama, or fallback) handles only narrative translation of already-sealed ForensicBundle objects. It does not compute scores, set thresholds, or emit verdicts. This boundary is marked in the architecture diagram and enforced by the code — not by a system prompt.

Judging Criteria Alignment

CriterionVIGÍA Implementation
Autonomous Executionvigia_agent.py — self-correcting loop, MAX_ITERATIONS=3, deterministic contradiction detection
IR AccuracyProbabilistic verdicts (0.0–0.99); confirmed vs. inferred always distinguished
Breadth & Depth21 tools; AbductiveHuntingStrategy prioritizes via value / (cost × spoofability)
Constraint Implementation_sanitize_path, @_rate_limit, magic-byte validation, Kassandra Protocol
Audit Trailchain_of_custody_hash (SHA-256), HMAC-signed audit chain, full AmicusCuriae
Usability5 modes: fallback (0 tokens), Claude Code + MCP, Ollama (local), batch agent, OpenWebUI

Theoretical Foundation

Charles S. Peirce — Abductive Semiotics

Every tool applies the triadic reasoning structure:

  • Firstness — What is the raw phenomenon? (the sign itself)
  • Secondness — Is this normal here? (the sign in context)
  • Thirdness — What habit does this reveal? (the inferred law / intent)

H. Paul Grice — Cooperative Principle Forensics

Honest communication follows four maxims (Quality, Quantity, Relation, Manner). Deception violates at least one. VIGÍA measures evaluative adjective density — emotionally overloaded language is a manipulation signature.

Dale Carnegie — Manipulation Pattern Recognition

Authority establishment · Flattery to system · Emotional appeal · Lesser-evil negotiation · False familiarity.

Umberto Eco — Significant Silence and Overinterpretation

"The perfect conspiracy leaves no obvious traces. If there are too many, someone planted them."

The absence of expected artifacts is itself evidence.


Academic Documentation

LanguageDocuments
Englishdocs/VIGIA_TECHNICAL_STATE_EN.md, KNOWN_LIMITATIONS.md, DAUBERT_JUDICIAL.md, VIGIA_STORY_EN.md
SpanishVIGIA_ESTADO_TECNICO_ES.md, DAUBERT_JUDICIAL_ES.md, INSTALL_ES.md, VIGIA_STORY.md
Russiandocs/academic/ (in progress)
Chinesedocs/academic/ (in progress)

Repository Structure

vigia-intent-analysis/
├── LICENSE                              ← Apache 2.0
├── README.md                            ← This file
├── KNOWN_LIMITATIONS.md                 ← L-001 to L-019 (Daubert transparency)
├── SUBMISSION_COMPLIANCE.md             ← Full compliance index for judges
├── INSTALL.md                           ← Extended installation guide (EN)
├── INSTALL_ES.md                        ← Guía de instalación (ES)
├── SECURITY.md                          ← Security policy
├── AUTHORS.md                           ← Anna Tchijova + VIGÍA AI Collective
├── DAUBERT_JUDICIAL.md / _ES.md         ← Daubert compliance rationale
├── VIGIA_STORY_EN.md                    ← Origin story (EN) — requested by Rob T. Lee
├── VIGIA_STORY.md                       ← Origin story (ES)
├── VIGIA_ESTADO_TECNICO_ES.md           ← Technical state document (ES)
├── CLAUDE.md                            ← Claude Code investigation playbook
├── pyproject.toml / requirements.txt
├── docker-compose.yml
│
├── vigia_agent.py                       ← Autonomous forensic agent (entry point)
├── vigia_api.py                         ← REST API (OpenWebUI / HTTP clients)
├── vigia_scorer.py                      ← Deterministic scorer (standalone CLI)
├── validate_case.py                     ← Case schema validator (EBS v1)
├── show_4_hashes.py                     ← Four-hash bundle display
├── vigia.html                           ← Mathematical logic simulator
├── vigia_commands_en.html               ← Command reference
├── vigia-es.html / vigia-ru.html        ← ES / RU versions
│
├── vigia/                               ← Main package
│   ├── vigia_sift_bridge_final.py       ← MCP server (21 tools, primary entry)
│   ├── core/
│   │   ├── ebs_v1.py                    ← Evidence Bundle Synthesizer
│   │   ├── caie.py                      ← CrossArtifactIncongruenceEngine
│   │   ├── trust_levels.py              ← HMAC-verified trust computation
│   │   ├── likelihood_engine.py         ← KDE + Ledoit-Wolf calibration
│   │   ├── vigia_scorer.py              ← Core scoring (Fraction arithmetic)
│   │   └── semiotic_detector_v2.py      ← Peircean + Carnegie + Grice detection
│   ├── forensics/                       ← Temporal, memory, document forensics
│   ├── inference/                       ← Abductive reasoning + hypothesis lineage
│   ├── security/                        ← Sandbox + Kassandra protocol
│   ├── sift/                            ← SIFT-specific bridge tools
│   ├── tools/                           ← MCP tool implementations
│   └── data/
│       ├── system_prompt_peirce.md      ← System prompt (ES)
│       └── system_prompt_peirce_EN.md   ← System prompt (EN)
│
├── forensics/
│   └── verify_ebs_v1.py                 ← Bundle verification (stdlib only, 0 deps)
│
├── data/
│   ├── cases/
│   │   ├── consolidated_canonical/      ← 52 canonical cases (VIGIA-CAN-001–052)
│   │   ├── converted/                   ← 18+ real cases (VIGIA-REAL-*)
│   │   ├── benign/                      ← 15 benign cases (VIGIA-BEN-*)
│   │   └── legacy/                      ← BREAK corpus (VIGIA-BREAK-*)
│   └── phonetic_dict.json               ← Russian/multilingual evasion dictionary
│
├── evidence/                            ← Real forensic artifacts (ROCBA, SRL rips)
│
├── results/
│   └── srl2018/                         ← Stark Research Labs 2018 outputs
│       ├── VIGIA-REAL-SRL-DMZ-FTP_bundle.json
│       ├── VIGIA-REAL-SRL-DMZ-FTP_bundle.json.sha256
│       └── VIGIA-REAL-SRL-DMZ-FTP_amicus_curiae.md
│
├── screenshots/                         ← Demo and test result screenshots
│   ├── diagrama1.png – diagrama8.png
│   ├── caso18.png, caso31.png, caso38.png

### CAN-018 — The Ghost in the Machine

847 commands at exactly 300.000-second intervals. Zero errors. Zero retries.
Temporal entropy: 0.00 bits.

![CAN-018](screenshots/caso18.png)
│   ├── casoreal7.png, casorealsrl.png
│   ├── selfcorection.png
│   └── test148.png, test3.png, test55.png, testreal.png
│
├── docs/
│   ├── vigia_diagrams.html              ← Interactive architecture diagrams
│   ├── VIGIA_TECHNICAL_STATE_EN.md      ← Technical state (EN)
│   ├── protocols/P2/                    ← P2 canonical vectors + SHA-256 manifest
│   └── academic/                        ← 193 module docs (EN/ES/RU/ZH in progress)
│
├── tests/                               ← 163 passed, 6 xfailed
│   ├── run_all_cases.py
│   ├── test_red_team.py
│   └── test_ebs_v1_integration.py
│
└── scripts/                             ← Utility and maintenance scripts
    ├── run_case.py
    ├── run_demo.py
    └── pre_release_check.py

AI Collective

MemberRoleContribution
Anna TchijovaPrincipal InvestigatorArchitecture vision, theoretical framework, case design, orchestration of the collective. "The One Who Refused to Let Deception Be Free."
Claude (Anthropic)Systems Integration EngineerModule integration, security hardening, LLMBackend unification, bridge architecture, forensic pipeline. "The One Who Connected the Wires."
Gemini (Google)Chief Tactical OfficerIoI theoretical framework, Peircean semiotics translation into forensic heuristics, investigate_autonomous, AbductiveHuntingStrategy. "The One Who Read the Enemy's Mind."
Kimi (Moonshot)Forensic Systems Specialistdetect_memory_habit_incongruence (Volatility), CrossArtifactIncongruenceEngine, AmicusCuriae narrative, tooling anomaly detection. "The One Who Assumed Malice in Every Semicolon."
DeepSeekSecurity AuditorP0 vulnerability identification, security hardening recommendations, TOCTOU fixes. "The One Who Said 'This Is Vulnerable, Fix It'."
Qwen (Alibaba)Determinism ParanoiaFloat determinism scaffolding, canonical JSON, hash chain verification, container hardening. "The One Who Turned Paranoia into Protocol."
Grok (xAI)Scoring ArchitectP2 scorer analysis, spoofability contextual modeling, acquisition_assurance mathematical formulation, calibration against NIST/DEF CON cases. "The One Who Demanded Mathematical Honesty."
ChatGPT (OpenAI)Adversarial Red TeamP2 stress testing, edge case discovery, epistemological validation of design decisions. "The One Who Asked the Uncomfortable Questions."

Architecture Screenshots

Architecture Diagram 1 Architecture Diagram 2 Architecture Diagram 4 Architecture Diagram 5 Architecture Diagram 6 Architecture Diagram 7 Architecture Diagram 8


Case JSON Validator

python3 validate_case.py data/cases/converted/VIGIA-REAL-001.json

Checks: required fields, valid evidence_type against CAIE whitelist, minimum acquisition_hash length (64 hex chars), examiner_id presence.


For Judges

This page exists solely to make evaluation easier.

You do not need to learn any commands. Every example below is a ready-to-run copy/paste shortcut that reproduces a specific result, benchmark, case, or validation claim presented elsewhere in this project.

The goal is transparency and reproducibility, not CLI training.

VIGÍA does not ask evaluators to trust reported results. Every benchmark, accuracy claim, determinism claim, validation result, and case outcome can be reproduced locally with the commands below.

If you only want to inspect the architecture, published cases, web simulators, or benchmark reports, this section can be ignored entirely.


Domain A — 117/117 deterministic accuracy

Claim: 117 cases, 100% correct in fallback mode (no API key, no LLM).

python3 run_all_agent.py --timeout 90

run_all_agent.py runs all 136 cases (Domain A + B + C combined).

Expected output:

Results: 134/136 PASS  2 FAIL

FAILED CASES:

VIGIA-AMB-001: agent=NOISE (exp=ABSTAIN)  [Domain B — L-012]
VIGIA-AMB-002: agent=NOISE (exp=ABSTAIN)  [Domain B — L-012]

Domain A (core metric): **117/117 PASS — 100%**

Unit test suite — 163 passed, 6 xfailed

Claim: 163 tests pass; 6 are xfailed (documented regressions with regression-preventing tests — see KNOWN_LIMITATIONS.md).

python3 -m pytest tests/ -v

Expected output: 163 passed, 6 xfailed


Deterministic outputs — same input → same SHA-256

Claim: Identical evidence always produces a bit-for-bit identical bundle. Verified by running the same case three times and comparing SHA-256 hashes.

PYTHONPATH=$(pwd) python3 tests/check_determinism.py

Expected output: three matching hashes — determinism confirmed.


EBS v1 cryptographic bundle verification

Claim: Every sealed bundle is independently verifiable using stdlib Python only, no VIGÍA code required. The verifier recomputes all hashes from scratch.

# SRL-DMZ-FTP — EBS v1 cryptographic verification (legacy pipeline format)
python3 forensics/verify_ebs_v1.py results/srl2018/VIGIA-REAL-SRL-DMZ-FTP_bundle.json --verbose

# REAL-008 Cridex — agent bundle integrity (vigia_agent.py format, verified via sha256 sidecar)
sha256sum -c results/agent_batch/VIGIA-REAL-008_agent_bundle.json.sha256

Expected output (SRL-DMZ-FTP):

Resultado   : PASS
Conformidad : Level 2 — Cryptographically valid
Checks      : 8/9 OK

Note: R5_ECL_BINDING: WARN (ECL absent) is the expected result on the SRL-DMZ-FTP bundle — Level 3 requires external chain anchoring, documented as a future feature. The WARN does not affect verdict integrity. The REAL-008 bundle uses the vigia_agent.py format; R6_DEVIL_ADVOCATE does not apply.


Four-hash forensic integrity display

Claim: Each bundle exposes four independently computable hashes covering the evidence graph, sealed bundle, HMAC audit chain, and independent EBS v1 verification.

python3 show_4_hashes.py data/cases/converted/VIGIA-REAL-008.json

Expected output: H1 graph_hash, H2 bundle_hash, H3 HMAC chain, H4 EBS verify — all GREEN.


Single case reproduction

Claim: Any published case can be reproduced end-to-end from the case JSON alone.

python3 vigia_agent.py --evidence data/cases/converted/VIGIA-REAL-001.json \
  --case-id VIGIA-REAL-001

Replace VIGIA-REAL-001 with any case ID from data/cases/converted/. Produces a sealed ForensicBundle with HMAC-signed audit trail.


Adversarial suite — Domain C, 14/16 handled

Claim: Extended adversarial harness — 25 cases total (Domain C BREAK corpus + additional stress tests). 22/25 handled correctly. 3 failures include documented limitations (L-015, L-016) plus one epistemic overconfidence case.

Expected output:

Total cases: 25  |  Passed: 22  |  Failed: 3  |  HIGH RISK false confidence: 0

'Failed' = system was overconfident under assumption collapse. This is the harness working correctly — see EPISTEMOLOGICAL NOTE in output. Domain C table (16/14) reflects the BREAK corpus subset only.

python3 run_adversarial_tests.py

Self-correction gate — VIGIA-REAL-007 live example

Claim: LLM returned MALICE 0.91; deterministic gate corrected to INTENT 0.74. self_correction_applied: true is sealed in the bundle.

python3 vigia_agent.py --evidence data/cases/converted/VIGIA-REAL-007.json \
  --case-id VIGIA-REAL-007

Expected: final_verdict: INTENT, final_confidence: 0.74, self_correction_applied: true


VIGIA-REAL-008 — Cridex banking trojan (CON LLM)

Claim: Memory forensics on cridex.vmem. reason_with_llm called. MALICE 93%, posterior 0.998, EBS v1 Level 2 verified. Bundle and Amicus Curiae available at results/real/VIGIA-REAL-008_bundle.json.

python3 forensics/verify_ebs_v1.py results/real/VIGIA-REAL-008_bundle.json --verbose

Expected: PASS — Level 2 — Cryptographically valid, R6_DEVIL_ADVOCATE: OK

python3 show_4_hashes.py data/cases/converted/VIGIA-REAL-008.json

Expected:

H1 graph_hash  : 94147b51c639cd0c...  PRESENT
H2 bundle_hash : 125f7f06af5a4f56...  PRESENT
H3 HMAC chain  : 6addf5b7d99a11d9...  OK
H4 EBS verify  : PASS — Level 2

Web simulator (no install required)

Claim: Full scoring pipeline available in-browser. No API key, no signup.

https://annatchijova.github.io/vigia/vigia_commands_en.html


License

Apache 2.0 License. See LICENSE.

Copyright (c) 2026 Anna Tchijova and the VIGÍA AI Collective.


"The question is not what happened, but why did someone make it happen — and who benefits from that interpretation?" — VIGÍA

Ver o original no GitHub

Bom para

Relacionados