Sovereignty isn't a feature. It's the foundation.
About
SMTRY is an AI infrastructure company built around a single conviction: the knowledge inside your work is your most valuable asset, and most tools throw it away at the end of every session. We build the memory layer that keeps it and puts it back to work. The architecture began as a private research platform called Project Symmetry. The name shortened. The premise didn't.
We are a small firm that builds like a lab, with cognitive science as the blueprint and a standing rule that a claim ships only after it survives production. SMTRY is a venture of J. I. Ashley Consulting, San Francisco.
What We Build
Most people using AI are building on rented ground. The tools are powerful and the data protections are real. But the accumulated knowledge of how you think, decide, and operate lives in someone else's ecosystem. When the session ends, the context resets.
SMTRY is built on a different premise. The reasoning engine can rent the best model available, but the memory layer belongs to you: the decisions you made, the patterns you recognized, the methods that proved out. What you know at year five is built directly on what you learned at year one.
One memory architecture, two products: Anamnesis, a persistent memory you can connect to the AI tools you already use, and Atria, the institutional intelligence platform built on the same foundation.
Anamnesis is the memory architecture as a product: a persistent, encrypted memory for the AI tools you already use. Your sessions are captured as they happen, reflected into typed memories, and consolidated into durable knowledge that follows you into every new conversation. Clear your context freely. Nothing worth keeping is lost.
Every account's memory is encrypted under its own key, and the whole archive stays visible, searchable, and deletable on your own dashboard. Browsing shows the shape of what you have stored without exposing its contents, and every new memory is screened before it is trusted, so poisoned or adversarial text does not quietly become part of it.
Under the hood it is MCP-native: one connector speaks the Model Context Protocol over streamable HTTP, so the same memory follows you across Claude Code, Claude Desktop, claude.ai, Cowork, ChatGPT, and the Codex and Gemini CLIs. Warm recall is measured in the 0.2 to 0.4 second range, and consolidation is measured too: on live accounts, a distilled memory carries up to 27 times its stored size in source context.
Automatic session capture runs in Claude Code today. The others connect for recall: Claude Desktop, claude.ai, Cowork, ChatGPT, Codex CLI, and Gemini CLI.
Every SMTRY product shares one core: a memory pipeline grounded in cognitive science. A session is captured as it happens, segmented into topic-bounded episodes, reflected into typed echoes, and consolidated into engrams: durable knowledge gathered into convergence zones. Each stage mirrors how human memory encodes, consolidates, and retrieves. On live accounts today, thousands of raw episodes distill into typed echoes and a compact set of durable engrams; retrieval rides compact sentence embeddings computed in milliseconds, with semantic clustering deciding what consolidates and provenance fields deciding what gets trusted.
Engrams are stored in a temporal knowledge graph: a web of typed connections rather than a flat list. When a task begins, the system traverses the graph from the current context outward, surfacing only the knowledge with direct relational bearing on the conversation in front of it. A traversal touches the neighborhood of the task at hand, so token cost stays bounded no matter how large the archive grows.
Picture finding your way by the stars rather than sailing aimlessly through the sea. Your destination is inferred by fixed points above and their relationships to each other, to the horizon, and to time itself. With sextant and map, not blindly in the dark. Engrams work the same way. When a task begins, the system reads the sky from wherever it stands instead of searching the entire archive.
Atria is the institutional intelligence platform: the coordination layer where specialized functions, configured entirely around a firm's domain, work in tandem. Each operates within a defined scope, contributes to shared institutional memory, and coordinates through a structured communication protocol. The architecture is extensible by design: any function can be built, deployed, and integrated without rebuilding the underlying intelligence layer. The nexus itself is a Go message bus with server-sent-event streaming; functions are Python processes speaking a shared protocol, so a new capability is a new process, not a rewrite.
The system is built on the premise that intelligence without accountability is noise. Every output passes through a structured decision hierarchy where signals are sequenced and weighted against each other, and conflicting data trips a circuit breaker instead of cascading. Quality gates and contrarian reviewers challenge every output before it reaches you.
Variant strategies run continuously in shadow evaluation against live decisions, and parameters that outperform are promoted automatically, so the platform improves with every cycle it runs. Every output is auditable and every parameter reversible.
The pipeline is model-agnostic by design. Today, frontier models handle the heaviest reasoning. In parallel, we train open-weight models with low-rank adaptation (LoRA): small, portable weight layers that teach an open model our reflection and consolidation stages without touching the base weights. Each stage that crosses our quality bar moves off the frontier APIs and onto hardware we run ourselves.
The destination is full memory sovereignty: the entire pipeline, capture through crystallization, running on systems you own. Your memory forms at home and stays there. The stack is deliberately boring and portable: open-weight models, LoRA adapters, local inference runtimes, and per-user encryption at rest. We already run parts of the pipeline this way in-house, evaluated shadow-mode against the frontier models they will replace. In current evaluation, a locally run open-weight model matches frontier verdicts on our reflection screening at 0.95 confidence, in 2 to 3 seconds per pass on consumer hardware.
The latest measured step, from our August 2026 holdout evaluation: an open-weight model of just eight billion parameters, quantized to two bits and running on a single consumer machine, distilled the full benchmark corpus and matched the cloud pipeline's retrieval quality exactly, at 0.94 evidence coverage on both arms. End-to-end answer accuracy recovered 17 of the cloud arm's 22 correct answers at zero marginal cost, with the remaining gap concentrated in temporal reasoning, a stage we are actively improving. The trade today is time: roughly 70 hours of local compute versus six minutes through a cloud batch API. Falling local-inference costs close that gap on their own schedule. The sovereignty does not have to wait for it.
Most tools in this space are built to do the work for you. The result is faster output, but a quieter, duller version of yourself.
This is a partner built around how you think, what you dream, and how you strive to be heard. An editor offering just the right contrarian view you never knew you needed. Built to learn your instincts, and the places where old habits masquerade as choices. A simple language model is a blank canvas. This is a world you've painted over a lifetime.
A collaborator that helps you be the best version of you.
Methodology
The architecture starts from a question about the firm rather than the model: what does it need to know, how confidently, and what happens when it is wrong? That is an epistemological problem before it is a technical one, and the engineering follows from the answer.
The approach is to define the knowledge requirement first, build the system to meet it, and challenge every output before trusting it. Parameters that perform earn the right to stay and are promoted automatically when they do. The rest is discipline: a conviction formed without evidence is an opinion, and we do not ship opinions.
The cognitive science came after the architecture existed. Tulving, Tonegawa, Müller and Pilzecker confirmed a design that was already running; they did not inspire it. When a century of memory research maps cleanly onto a system built from engineering constraints alone, the problem was real from the start.
Contact
For partnership inquiries, press, or investment conversations: