Memory, coordination, and execution infrastructure for reliable AI agents.

Underpass AI helps agents recover context, coordinate specialist work, execute through governed tools, and leave auditable evidence behind.

We do not build foundation models. We build the operational substrate around them: navigable memory, event-driven coordination, governed execution, evidence, policy, and observability.

Explore GitHub Read the KMP article Contact

Problem

Agents are getting better at work, but weak infrastructure makes them hard to trust.

Modern agents can read code, call tools, run tests, and operate across complex workflows. But most agent systems still lose context between runs, repeat failed attempts, hide state inside frameworks, and produce weak audit trails.

  • They lose relevant context between executions.
  • They repeat failed attempts because past process memory is not navigable.
  • They cannot always explain what evidence supported a decision.
  • They execute tools without enough governance or inspection.
  • They are difficult to observe, debug, and audit in production-like systems.

Platform model

Three infrastructure planes around the model.

Underpass separates memory, coordination, and execution so each part can be inspected, tested, and evolved independently.

Domain event
Specialist agents
Memory KMP by Underpass
Coordination MADE by Underpass
Execution AXLR
Evidence + memory update

Agents should not start every task from zero. They should recover scoped memory, understand previous attempts, coordinate the next step, execute through controlled runtimes, and write evidence back into the system.

  1. Domain event
  2. Specialist agents
  3. KMP by Underpass restores scoped memory
  4. MADE coordinates deliberation and work
  5. AXLR executes agent turns and tools
  6. Evidence is recorded
  7. Memory improves for the next event

Components

Public infrastructure components.

KMP preserves memory, MADE coordinates agents and people, and AXLR runs agent work and tools. Each component has its own public repository and contracts.

  1. Public memory plane

    KMP by Underpass

    Local-first memory for Codex, Claude Code and Hermes Agent. Decisions, evidence and the reasons behind them, preserved through time.

    • Decisions and evidence stored locally in SQLite.
    • Scoped recall with topics, dimensions and explicit clocks.
    • Ask returns stored evidence, or UNKNOWN when it cannot answer.
    • Relations preserve why a decision changed and what proves it.
    • ChronoLoom lets people and agents explore the same memory view.
    • Native plugins and progressive guidance for coding agents.
    • Optional model-assisted retrieval; external judgments require opt-in.

    How you run it

    Embedded Local memory across projects and agent hosts.
    The default path runs on your machine over MCP and SQLite, with no database server, KMP account or API key required. Codex and Claude Code use native plugins; Hermes uses native setup. Hosts can share a local store, and reviewed memory bundles travel with your project. The repository has setup instructions; a source install of the engine is also available. cargo install kmp-mcp --locked
    Cluster Memory shared and audited across teams and services.
    An optional, self-operated service with typed gRPC APIs, Neo4j, Valkey and NATS JetStream, deployed with Helm on Kubernetes. You operate TLS, identity, authorization and observability. Backend-specific capabilities are documented in the repository.
    View KMP by Underpass on GitHub
  2. Public local execution runtime

    AXLR

    An agentic execution runtime for trusted local workspaces. AXLR runs model turns, tools and resumable sessions; KMP and MADE connect over MCP for memory and orchestration.

    • Interactive console with streamed model output and saved sessions.
    • Read, write, edit and exec tools with explicit approval.
    • Codex-compatible plugin packages and standard MCP connections.
    • Go library and one-request JSON worker for host integrations.
    • Trusted-local Linux workspace with an explicit execution boundary.
    View AXLR on GitHub
  3. Public coordination plane · 0.9.1

    MADE

    Multi-Agent Deliberation Engine: durable procedures for agents and people, from a local change review to a system of coordinated ceremonies.

    • Define steps, roles, parallel work and human approval in YAML.
    • Resume published ceremonies from an auditable event history.
    • Pause work, enforce deadlines and carry evidence to a successor.
    • Send questions to working agents and track their acknowledgements.
    • Compose published ceremonies into systems with shared supervision.
    • Let an integrator host follow results, blockers and human decisions.
    • Your host supplies agents and tools; MADE validates their progress.

    How you run it

    Embedded Coordinate work in Codex, Claude Code or your Rust app.
    Start with the local plugin and SQLite, with no MADE account or deployed service. Setup configures the store and authorization. Published ceremonies survive restart; the host performs the work. Rust applications can embed the same engine. For the manual Cargo route below, follow the repository's setup guide before starting MCP. cargo install made-mcp --version 0.9.1 --locked
    Cluster Operate a shared coordination service for your hosts.
    An optional, self-operated gRPC service with PostgreSQL persistence, NATS messaging and Helm/Kubernetes deployment. Configure provider-backed councils, output contracts and an optional LLM judge for deliberation, with metrics and traces. Operators own identity, authorization, providers and host activation.
    View MADE on GitHub

Why now

Agentic systems are moving from demos to operational workflows.

LLMs are becoming capable enough to use tools, inspect code, run commands, and participate in real engineering workflows. That creates a new infrastructure problem: memory, governance, auditability, and observability need to become first-class parts of the system.

  • Software engineering is one of the first domains where agentic workflows can produce measurable feedback.
  • Tool-using agents need visible execution boundaries and approval checks.
  • Long-running agents need memory that can be navigated, not just retrieved.
  • Human operators need evidence trails, traces, and failure classification.
  • GPU-backed local and distributed inference is a strategic technical direction.

Writing

From the lab notebook.

Longform notes on the ideas behind Underpass AI: navigable agent memory, auditable multi-agent deliberation, and the economics of running agents in production.

  1. AI infra

    I let my GPU workers shut themselves down after five minutes

    Running evidence-bound agent reviews on ephemeral AWS GPU workers while preserving traces, logs, metrics, and decision artifacts after shutdown.

    Underpass AI · English
  2. MADE

    No queremos agentes que contesten. Queremos decisiones que se puedan auditar

    A multi-agent design meeting as a declarative ceremony: proposals, peer critique, an LLM judge — and the whole decision replayable as an OpenTelemetry trace in Grafana.

    Dev.to · Spanish
  3. Operator

    Operator: cuando responder no basta

    Training Qwen 0.5B with LoRA to emit exact Kernel Memory Protocol actions from visible memory state, without turning it into a general reasoning model.

    Dev.to · Spanish
  4. KMP

    Building Kernel Memory Protocol: navigable memory for AI agents

    Why agent memory has to be temporal, multidimensional and auditable — and what a kernel-style protocol for it actually looks like in practice.

    Dev.to · English
  5. Event pipeline

    What an event-driven agent pipeline looks like when you trace it end-to-end

    Walking a full agent pipeline as a stream of events: who emits what, where decisions get coordinated, and what the trail actually proves about behaviour.

    Dev.to · English
  6. Economics

    Why event-driven agents reduce scope, cost and decision dispersion

    The architectural and economic case for event-driven coordination over chatty agent loops: smaller scope, cheaper retries, fewer dispersed decisions.

    Dev.to · English
All posts on dev.to/tirsogarcia

Open source

Built in the open.

Underpass AI is developed around open infrastructure principles. The public GitHub organization exposes the technical direction, the core repositories, and the foundation for future community collaboration.

Memory

KMP by Underpass

kmp · Rust · Apache-2.0 · formerly rehydration-kernel

View KMP by Underpass repo →
Execution

AXLR

AXLR · Go · local agentic execution

View AXLR repo →
Coordination

MADE by Underpass

made · Rust · Apache-2.0 · formerly underpass-choreographer

View MADE repo →
Explore the GitHub organization

Founder

Founder-led technical infrastructure.

Underpass AI is created by Tirso García Ibáñez, a software architect with 15+ years of experience across software engineering, architecture, distributed systems, cloud-native platforms, and technical leadership.

The current focus is AI infrastructure for agentic systems: navigable memory, durable coordination, inspectable local execution, and production-oriented architecture patterns for LLM agents.

linkedin.com/in/tirsogarcia

Contact

Talk to Underpass AI.

Interested in reliable agent infrastructure, technical validation, open-source collaboration, or early-stage product conversations?