✦ Context manager · Multi-model AI · macOS · Linux · Windows

The AI that remembers everything
and never repeats a mistake

Use it as a powerful context manager — search months of conversations, resume any project instantly, never re-explain your preferences. Or use it to run multiple AI models simultaneously and let mechanism design pick the best answer. Both, always on.

macOS (arm64) Linux (x64) BETA Windows (x64) BETA
v0.9.0 · Free · Requires your own API keys · Read the tutorial → · GitHub ↗
Linux and Windows builds are new and need further testing in real environments. macOS (arm64) is the primary tested platform. If you hit issues on Linux or Windows, please Report a Bug from inside the app so we can track them.
AUA-Veritas — showing GPT-4o and Claude Sonnet answering a startup database question, with welfare scores, confidence High, and preference saved confirmation

GPT-4o vs Claude Sonnet in Max accuracy mode — welfare scores, peer review, preference memory

Quick start
Up and running in 4 steps

You only need one API key to start. Add more later to unlock multi-model comparison.

1

Download

Pick your platform from the v0.9.0 release page ↗

macOS arm64 — .dmg Linux x64 — .AppImage needs testing Linux x64 — .deb (Debian/Ubuntu) needs testing Windows x64 — .exe needs testing
2

Install

macOS

Mount DMG → drag to Applications → run in Terminal:

xattr -cr /Applications/AUA-Veritas.app

ℹ If macOS asks "wants to accept incoming network connections" — click Allow. The app runs a local server on your machine so the interface and backend can talk to each other. It does not expose anything to the internet.

Linux

chmod +x AUA-Veritas-*.AppImage
./AUA-Veritas-*.AppImage

Windows

Run AUA-Veritas Setup 0.9.0.exe → launch from Start menu

3

Add an API key

Open Settings ⚙ and paste your key. One key is enough to start — add more to unlock multi-model comparison.

OpenAI ↗ Anthropic ↗ Google (free) ↗ Groq (free) ↗
4

Start chatting

Ask anything. Use High or Max accuracy for important questions to see multiple models compete. Correct an answer once — Veritas remembers it forever.

Accuracy mode cheat-sheet
Mode What happens Cost Best for
Fast One model, live streaming Quick drafts, casual queries
Balanced One model + cheap cross-check ~1.05× Everyday use
High All models in parallel, VCG picks winner Important decisions, research
Max All models + peer review by judge models ~N+0.1× High-stakes answers
Context manager
Pick up any conversation
exactly where you left off

Leave a project for three months. Come back, type a follow-up, and the AI already knows your stack, your preferences, your previous decisions — without you re-explaining anything.

Every conversation is fully keyword-indexed. Search across months of work in milliseconds. Find that architecture decision, the code snippet you wrote last Tuesday, the reason you chose Postgres over MongoDB.

🔍
Full-text keyword search
Every message is keyword-extracted at send time and indexed locally. Search finds relevant chats across all your history instantly.
🧠
Automatic context recovery
When you return to a conversation, each model self-generates a recovery prompt from your stored corrections and preferences. No manual re-briefing.
📋
Persistent corrections, forever
Preferences and corrections survive indefinitely. Tell it once that you prefer TypeScript over JavaScript — it applies that everywhere, including chats you start months later.
Search chats…
🔍  "postgres index LIKE query"
3 months ago · Backend architecture
"…For prefix LIKE queries, a standard B-tree index works. For arbitrary substring searches, use a GIN index with pg_trgm…"
5 months ago · Database design
"…we chose Postgres because ACID matters more than schema flexibility at this stage…"
↩ Resume either conversation — AI already knows your context
69.6%
reduction in repeated errors
+10.5%
routing correctness gain
r=0.46
utility–correctness correlation
7
frontier models in parallel
Why Veritas
One AI is not enough

Every frontier model has blind spots. Veritas runs all of them on every query and uses a game-theoretic mechanism to pick the winner — turning competition into correctness.

🤖 A typical AI assistant

  • Forgets everything when you close the window — no persistent memory
  • Repeats the same mistakes — corrections don't carry across sessions
  • No search across past conversations — you re-explain context every time
  • No way to know when it's hallucinating vs genuinely confident
  • Same model for every query regardless of domain strength

AUA-Veritas

  • Full-text search across all conversations — find anything in seconds
  • Resume any project after months — AI already knows your context
  • Corrections and preferences persist forever, across every chat
  • Multi-model peer review surfaces uncertainty explicitly
  • Domain-aware routing gets measurably better over time
Five layers, all running on every query

Each layer adds correctness. Together they form a self-improving system that compounds over time.

1

Memory injection

Before every query, Veritas scores all stored corrections and preferences against the current question using 8 factors: relevance, importance, recency, confidence, staleness, and more. Only corrections above a threshold are injected — no token waste.

2

Multi-model competition via VCG mechanism design

All enabled models answer simultaneously. Each reports its self-assessed domain using a DOMAINS: tag. A domain-decomposed Vickrey–Clarke–Groves welfare function scores each model: W_i(q) = Σ p(j|q) · u_i(j) where u_i(j) is the model's volume-normalized win rate in domain j.

3

Peer review (High / Max accuracy)

When models disagree, a separate reviewer model checks the winner's answer for accuracy. Correct → reward. Incorrect → correction stored. You can always override by picking any model's answer — that preference is recorded and shifts future routing.

4

Automatic correction detection

When you reply with something like "No, it's 53" or "I prefer metric units", Veritas detects the implicit correction using a semantic similarity model. You're asked to confirm, then it's stored permanently and injected on all future relevant queries.

5

Compliance monitoring

A compliance monitor checks every response against active instructions. If a model stops following a rule for 2+ consecutive responses, the next system prompt reinforces it in bold. The domain tree grows automatically from model self-reports — no manual taxonomy needed.

Features
Everything you need, nothing you don't

Use it as a powerful AI assistant with multi-model verification, or simply as the AI that never forgets your context. Both modes are always on.

🧠

Persistent memory

Corrections, preferences, and domain-specific rules survive across sessions. The system never forgets what you've taught it.

⚖️

VCG mechanism design

Game-theoretically optimal model selection — models are incentivised to report their true domain competencies, not just sound confident.

🌐

Dynamic domain tree

Domains grow naturally from model self-reports. "constitutional law" and "molecular biology" become their own nodes when data justifies it.

🔍

Look Under the Hood

Every decision is visible: decision chain, welfare scores, peer review verdict, confidence calibration, domain routing, correction history.

🔒

Private by default

All data stays on your Mac. Encrypted SQLite database. No telemetry, no cloud sync, no vendor lock-in. Your API keys, your data.

🚀

Fast startup

Backend binary launches in milliseconds. WAL-mode SQLite for all DB operations. Cache pre-warm on startup. Instant on return.

🤖

Local model support

Run Ollama models alongside frontier models. Tag local models as domain specialists — they compete on equal footing in VCG elections.

🐛

In-app bug reporting

One click to report a bug. Goes directly to a private repo. Anonymous machine token — no personal data unless you opt in.

📊

Live cost tracking

Real-time per-model token pricing. Session cost tracked to three decimal places. No surprises on your API bill.

For curious readers
Technical documentation

Everything about how AUA-Veritas works — from the database schema to the VCG mechanism, domain ontology, and architecture decisions.

🏗️

Architecture

Multi-model VCG routing, welfare scoring, correction memory, context backup system, domain ontology. Full technical design.

🗄️

Database Schema

All 17 SQLite tables — conversations, messages, model_runs, corrections, backups, search index, domain ontology — every column and index.

📖

Tutorial

Step-by-step guide to getting the most out of AUA-Veritas: accuracy modes, corrections, projects, context backups, local models.

📂

All docs on GitHub

Design log, VCG domain utility analysis, phase 12 domain ontology, compliance monitor, context manager test suite, and more.

⚙️

AUA Framework

The open-source framework powering AUA-Veritas. Build your own adaptive multi-model LLM system. Django-style, batteries included.

🗺️

Roadmap

What was built, what's next, and the lessons learned from shipping AUA-Veritas to production — including Phase 13 backport items.

Up and running in 3 minutes
1

Download and install

Download the latest .dmg from GitHub Releases. Mount, drag to Applications, right-click → Open to bypass Gatekeeper on first launch.

2

Add your API keys

Click the ⚙️ Settings icon. Add keys for any combination of OpenAI, Anthropic, Google, and Groq. You only need one — but more models means better VCG elections.

3

Ask anything

Start chatting. Use Balanced mode for everyday queries, High or Max for anything important. Corrections are stored automatically — the system learns from every interaction.

Full tutorial → GitHub ↗