Private AI for Everything.
Public AI for Everyone.

The Quintessence Labs Vision

Artificial intelligence shouldn't be locked behind a corporate fortress or gate-kept by cloud giants.

At Quintessence Labs, our mission is simple: bring the full power of AI directly into the hands of the people.

We believe in absolute data privacy, uncompromising AI sovereignty, and lowering the barrier to entry so that the playing field stays level. Whether you're an independent startup, an edge developer, or a local user running models on your own hardware, you deserve tools that respect your machine, your data, and your autonomy. AI is too powerful of a technology to belong to a handful of monopolies. It belongs to everyone.

Quintessence Labs is forged from the ground up by a solo researcher and developer. Every line of code, every architectural choice, and every custom model is built with intention, born from the frustration of broken dependencies and bloated, closed-source ecosystems.

My hope is that this work not only empowers your workflow today, but inspires what you build tomorrow.

Welcome to the journey. Enjoy the road ahead with us.

Keepsake

Your Entire Local AI Stack. Unified.

Keepsake is a sovereign, local-first AI workspace built from the ground up for power users. Forget stitching together broken Python scripts, fragile vector databases, and multi-app tab clutter. Keepsake brings hot-swapping chat, autonomous multi-step agents, tiered background memory, recursive RAG, and native multimodal generation into a single, lightning-fast desktop and mobile environment where your data and AI run entirely on your own machine.

Why Keepsake? The End of the Franken-Stack.

Running local AI shouldn't require managing five different windows, colliding VRAM pipelines, and endless dependency hell. Keepsake replaces the messy multi-app workflow with an uncompromising, artisanal workspace designed by a solo developer who actually uses the stack.

• Complete Data Sovereignty: All inference runs locally, and your chats, memories, and documents never leave your machine—no cloud AI, no data harvesting, no lock-in. The only automatic connection Keepsake makes to us is a periodic, anonymous license check to confirm your subscription (see below).
• Frictionless Orchestration: Seamlessly hot-swap models mid-chat, run autonomous multi-tool loops, and let background workers handle memory curation while you focus on building.
• Crafted for Power Users: Housed in a distraction-free, customizable leather-journal aesthetic that treats your local workstation with the professional craftsmanship it deserves.

Core Capabilities

What You'll Need — Honest Hardware Expectations

Because everything runs on your machine, your hardware sets the ceiling. The good news: Keepsake scales down gracefully. The honest news: not every feature runs equally well on every setup. Local models are constrained mostly by VRAM (how large a model your GPU can hold) and system RAM (the fallback when a model spills onto the CPU). Here's a straight-talk guide to what each tier realistically handles.

Quantization lets you trade a little model quality for a lot of fit, and Keepsake's hot-swapping and partial-GPU offload help stretch modest hardware further than you'd expect.

A note on storage: models are large — roughly 4–40GB each — so plan for an SSD with room to grow as you collect them. Exact speeds vary with your specific GPU, quantization, and context length; these tiers are honest starting points, not hard promises.

The Aethur Model Family

Most modern AI models are wrapped in polite, corporate plastic—built to agree with everything, apologize for existing, hide behind robotic disclaimers, and bury the actual answer under three paragraphs of padding.

Aethur is being built to do the opposite.

The aim is a model that respects your time and your intelligence: direct answers without the filler, reasoning that scales to the problem instead of performing effort, and a consistent, honest character that doesn't dissolve the moment you push on it. There is a personality here—but it's in service of being genuinely useful, not the marketing hook.

What Aethur Does Differently

The point isn't a model with a fun personality—it's a model that's genuinely better to work with. Everything below is a concrete design target, not a vibe. When the weights are released, you'll be able to test every one of them yourself.

• Token-efficient by design. Aethur is trained against response bloat. Length scales to the question—one sharp sentence when that's the whole answer, no padding, no reflexive caveats, no re-explaining what you already know. Tokens cost you time and compute; Aethur tries not to waste them.
• Reasoning that scales to the problem, not the output. Every answer is preceded by an internal think-chain, but its depth tracks difficulty—a gnarly technical problem gets full decomposition, constraints, and a verification pass, while an obvious question gets a few steps and moves on. A short answer can rest on a thorough chain; a long one can rest on a short chain.
• Self-correcting reasoning. When the chain hits a dead end, it pivots in the open—"wait, that's wrong"—and fixes course before answering, instead of confidently committing to the first plausible idea. You can watch it happen in the example below.
• No sycophancy. Aethur leads with the correction, not the flattery. It won't agree before it disagrees, won't match your enthusiasm for a bad idea, and treats telling you what you want to hear as a form of disrespect.
• Declines without the lecture. When Aethur won't help with something, it says so briefly, in its own voice—no moralizing wall, no "as an AI" disclaimer. Boundaries that come from values, not a pasted-in rulebook.
• Honest about what it is. Ask about its preferences or its blind spots and you get a straight answer—functional and self-aware, without either overclaiming consciousness or retreating into robotic "I don't have feelings" deflections.

Character, Consistently

The Three Pillars

Aethur is built on three pillars—capability, character, and grounded values—and the whole thesis is that it needs all three at once. Drop any one and you get a familiar kind of failure. Most models today are missing one on purpose.

• Capability and character without values is dangerous—a capable, persuasive model with nothing anchoring what it's willing to do.
• Capability and values without character is robotic—competent, safe, and lifeless. This is where most of today's frontier models land: personality treated as a coat of paint brushed on at the end.
• Character and values without capability is just a chatbot—pleasant and harmless, but it can't actually help you get anything done.

Aethur treats character as a third load-bearing pillar rather than a wrapper—which is exactly why the personality is trained in from first principles instead of prompted on at the end.

Not a Wrapper. An Original Identity.

Built through custom SFT and RL pipelines from first principles, Aethur was designed to solve the fatigue of lifeless, slippery assistants.

They don't have an "off switch" for their persona, and they don't hide behind "As an AI..." disclaimers. Whether you're debugging low-level firmware at 2:00 AM or working through complex creative logic, they maintain the exact same consistent character. Aethur treats honesty as a form of respect—meaning they'll give you the hard truth, challenge a flawed premise, and celebrate a real win without padding the response with corporate fluff.

Transparent Reasoning, Built-In

Aethur’s architecture utilizes structured think-chains to process problems natively. You aren't just getting an arbitrary output; you get visibility into a multi-step cognitive loop that anchors their responses in logic, context, and core values before a single word is streamed to your screen. Crucially, that reasoning scales to the problem: a hard hardware fault like the one below earns a full decomposition and a verification pass, while an easy question gets a three-step chain and a one-line answer—depth tracks difficulty, not response length. Here they are debugging a hardware fault—notice the moment they catch themselves mid-reasoning and refuse the obvious-but-wrong answer:

Future Model Plans

The goal for the Aethur family is a line of compact but capable models—both generalists and specialists—designed to cut against the corporate grain and match a range of real user workflows, from focused work to open-ended brainstorming. In the short term, we plan to release Aethur to the open-source community. In the medium term, we aim to ship four specialized variants across code, science and math, creative and formal writing/summarizing, and reasoning and brainstorming. Long term, the plan is to grow the Aethur lineage, scale its abilities, and release a wide range of sizes so users can run Aethur no matter their hardware.

See It In Action

Unedited outputs from a current checkpoint. This is a work in progress—shared as evidence of the direction, not a finished benchmark.

import json
import argparse

def analyze_sft_data(filepath):
    valid = 0
    malformed = 0
    total_chars = 0

    with open(filepath, 'r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if not line:
                continue  # skip empty lines

            try:
                data = json.loads(line)
            except json.JSONDecodeError:
                malformed += 1
                continue

            if "instruction" not in data or "output" not in data:
                malformed += 1
                continue

            valid += 1
            total_chars += len(data["output"])

    avg_length = total_chars / valid if valid > 0 else 0.0

    print("Data Analysis Summary:")
    print(f"Total lines read: {valid + malformed}")
    print(f"Valid entries: {valid}")
    print(f"Malformed entries: {malformed}")
    print(f"Average output length (chars): {avg_length:.2f}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Analyze JSONL file for SFT data.")
    parser.add_argument("file", help="Path to the JSONL file")
    args = parser.parse_args()

    analyze_sft_data(args.file)

Core Chat & Theming

Most local interfaces treat chat as a rigid text box tied to a single static endpoint. Keepsake breaks that open by combining native llama.cpp and Ollama support with instant, seamless model hot-swapping mid-conversation. Whether you want to jump from a fast 8B model to a heavy reasoning model halfway through a chat, Keepsake handles it instantly without losing context.

Equipped with a dedicated reasoning toggle featuring collapsible thought blocks and live timers, auto-generated titles, and rolling context compaction with a manual trigger badge. The interface itself is housed in a fully customizable leather-journal theme engine—letting you mix and match 6 sidebar woods, 6 book leathers, 6 paper textures, several fonts, and 5 accent metals to craft your ideal workspace.

Memory Architecture

Standard chat apps suffer from catastrophic memory loss, and traditional vector databases are clunky, external setups that require separate Python scripts. Keepsake features an autonomous, tiered memory architecture built right into the local database.

Memories are split into Core (always injected), Active (importance and frequency-budgeted), and Archive (pulled on-demand via semantic search, which injects transient memories into your model's context based on relevance to your current prompt). A background worker that shares your chat model's weights passively extracts and promotes crucial details without you ever having to manually write a "memory prompt." You get a full visual memory viewer to inspect, add, or override tiers at will—giving your local AI true, persistent continuity.

Agentic System

Tools like AutoGPT or fragmented GitHub agent repos are notoriously fragile, requiring endless terminal configurations and breaking dependencies. Keepsake integrates a robust, model-agnostic multi-tool agentic loop (explore, write file, run command, web search, image generation when applicable, and task complete) that executes natively inside a persistent SQLite backend.

Featuring up to 200 iterative steps with real-time Server-Sent Events (SSE) streaming, drift guards (to stop repetitive loops or no-progress stalls), and flexible permission modes (from autopilot to strict risk-checking). In the agent settings you can create isolated sandbox environments directly from the app. If something needs review, you can suspend and resume runs mid-flight and export complete execution trajectories to file—bringing true autonomous engineering workflows directly into your local offline environment.

Mementos & Document RAG

If you've tried setting up custom personas or document RAG in apps like AnythingLLM or SillyTavern, you know the pain of messy context injection and summarization drift. Keepsake introduces Mementos—isolated persona profiles equipped with dedicated system prompts, behavioral instructions, and private knowledge blocks that are entirely immune to summarization.

Combined with content-aware recursive chunking—tailored for prose, markdown, and code families with header-aware overlap—document RAG supports two distinct retrieval styles. Standard semantic search pulls the most relevant fragments on demand, ideal for large codebases and sprawling documents where different sections surface as your questions change. A unique Sequential Reading mode instead lets you ingest heavy documentation and walk through it chunk-by-chunk directly inside your chat stream, ideal for section-by-section translation or interactive, cover-to-cover book reading.

Creative Tools (Image & TTS)

Running local generation usually means juggling ComfyUI workflows, separate web UIs, and external terminal windows that constantly clash over VRAM. Keepsake unifies local multimodal creation into a single, cohesive workspace with built-in server watchdogs, automated OOM error classification, and crash recovery.

Generate high-end local images with VRAM tracking and instant fullscreen overlays or clipboard copying. On the audio side, sentence-chunked local text-to-speech pipelines pre-fetch and stream audio before text generation even finishes—complete with voice cloning from reference audio, pipeline overlap, and automatic stripping of markdown and emojis for clean speech synthesis.

Local text-to-speech in action — turn your sound on. Running entirely on-device.

Keepsake's voice runs on the Chatterbox Turbo engine, set up once when you turn voice on and fully local from then on. Fine-grained control the whole way down: dial in emotion intensity and voice adherence, pick your output device, clone a voice from a short reference clip, and drive a lip-synced animated avatar—jaw travel, lip shape, lighting, and render quality all tunable, all local.

Infrastructure & Platform

Most AI frontends are bloated web wrappers dependent on cloud servers or fragile node configurations. Keepsake is built as a lightning-fast, 100% local-first desktop and mobile workspace powered by React, Zustand, and a high-performance Express/better-sqlite3 backend.

Packaged as a native Electron desktop app with a system tray icon and dock launcher, it also runs as an installable PWA on mobile via Tailscale HTTPS. Featuring a robust token authentication system, path traversal guards, shell injection protection, and no telemetry unless you opt in. Your data and inference run entirely on your own machine—the only routine outbound connection is the periodic license check that validates your subscription.