Sovereign agent infrastructure · trust substrate · formal verification · immersive systems

I build tools that let autonomous agents remember, verify, execute, and leave evidence.

My work sits at the intersection of AI trust infrastructure, formal verification, macOS semantic automation, forensic memory, and cinematic web systems. The operating thesis:

Agents do not need more chat. They need memory with provenance, execution with guardrails, and evidence that survives inspection.

Tamper-evident memory, audit trails, and verifiable lineage for AI agents.

• cryptographic ledger for agent memory and decisions
• verification membrane (guards) before durable writes
• saga-pattern write path with compensating transactions
• replay, export, signatures, and offline verification
• designed for agentic systems where logs are not enough

Sovereign Agentic Architecture Registry — the definitive hub for multi-agent design patterns.

• CORTEX protocols and swarm topologies
• Industrial Noir design system for agent interfaces
• pattern library for guardrails, consensus, and memory admission

A programming language where trust doesn't compile. Formally verified smart contracts via Z3 SMT solver.

• contract verification at compile time
• SMT-backed proof obligations
• designed for adversarial environments where bugs are exploits

Agent Specification Language — open standard for formally verifying autonomous agent behavior.

• behavioral contracts for AI agents
• machine-checkable safety properties
• MIT licensed specification

Semantic GUI automation for macOS.

• structured traces for UI actions
• safety gates and deterministic execution paths
• bridge between natural-language intent and desktop execution

Sovereign macOS memory pressure daemon.

• 4-tier graduated response to memory pressure
• per-app RSS budgets
• predictive swap exhaustion

Homebrew formulae for borjamoskv tools — brew tap borjamoskv/tap.

Personal research surface for essays, artifacts, and immersive interfaces.

Interactive demo: Run → Break → Verify → Export.

Immersive audit microsite exploring cinematic front-end direction.

GitHub repo growth copilot: audit discoverability, generate launch kits.

focus:
  - verifiable agent memory (CORTEX Persist)
  - formal verification for smart contracts (Anvil)
  - behavioral specification for AI agents (ASL)
  - adversarial evaluation of agent guardrails
  - trust infrastructure for autonomous software
  - macOS system-level daemons (cortex-ram-guard)

principles:
  - verify before persist
  - evidence over rhetoric
  - local-first when possible
  - deterministic execution paths
  - beautiful systems are easier to operate

stack:
  languages: [python, rust, typescript, javascript]
  verification: [z3, smt, formal proofs, merkle chains]
  interfaces: [next.js, react, cli, macos automation]
  substrate: [sqlite, hash chains, structured traces]
  aesthetics: [industrial noir, high-contrast, cinematic]

I am building a practical architecture for sovereign agents:

1. memory that can be inspected, replayed, and challenged
2. guards that treat every input as adversarial until validated
3. execution traces that connect intent, tool calls, outcomes, and state changes
4. formal specs that make agent behavior machine-checkable
5. interfaces that make complex systems legible without flattening them

The goal is not to make agents feel magical.

The goal is to make them accountable.

• Website: cortexpersist.com
• Profile: portrait.so/borja
• Music: borjamoskv.bandcamp.com
• X: @bakaladetroya
• Instagram: @borjamoskv

Build the substrate. Prove the state. Ship the artifact.

CORTEX Live Agent Surface

Wake -> Guard -> Store -> Hash -> Verify -> Project