Frequently asked questions

This is where the architecture matters most.

What gets remembered is not everything said in a conversation. The system filters extracted information through quality checks before storage. Casual chatter, contradictions, and low confidence claims are filtered out. Only structured, verified knowledge enters memory.

What gets forgotten is governed by three mechanisms working together. Memories that aren't reinforced over time gradually lose confidence, the same way human memory weakens for information that isn't revisited. Memories explicitly contradicted by new information get versioned and updated, not silently overwritten. Users can also explicitly remove information.

How hallucinations are handled comes down to the verification stage in our extraction process. When the system pulls structured information from a conversation, it cross checks against existing memory before storing anything new. Information that fails verification is discarded.

This is genuinely hard work. Cognition that selectively remembers, intelligently forgets, and resists hallucination is one of the open problems in the field. We're not claiming to have solved it. We're claiming to have built a system designed around the right principles, and we're making it better continuously.

The path to genuinely intelligent AI runs through this problem. We're working on it.

This is the hardest engineering problem in persistent memory systems. Most attempts get it wrong.

Memory becomes wrong in three ways. Information was wrong when stored. Information was right but the world changed. The system inferred something that wasn't true.

Anant handles each differently.

For information that was wrong when stored, the verification stage during extraction catches most of these before they enter memory. What slips through gets caught later when contradicting information arrives. The newer information doesn't silently overwrite. The system creates a versioned update, marking the older claim as superseded while retaining it for audit.

For information that was right but the world changed, like a person's job title being true in March but false in May, our temporal architecture handles this through valid periods. Memories carry the time window they were true within. Retrieval scopes to the relevant period.

For inferred claims that turn out wrong, this is where belief states matter most. Inferred memories carry lower confidence than directly stated ones. They surface in retrieval with their uncertainty intact, and they're the first to lose confidence over time without reinforcement.

The system isn't infallible. No memory system is. The difference is that it's designed to be wrong gracefully, to carry uncertainty as a first class signal, and to update as new evidence arrives.

This is the question that exposes whether a memory system is actually thought through or just a thin layer on top of vector storage.

Naive memory systems grow linearly. Every interaction adds data. Retrieval gets noisier as the corpus expands. Eventually the system either slows down, returns irrelevant results, or both.

We designed Anant around the fact that biological memory doesn't work this way. Humans don't remember every detail of every interaction. Memory consolidates over time. Specific episodes get compressed into general patterns. Unimportant details fade. Important context strengthens through reinforcement.

Our consolidation cycles operate on the same principle. Periodically, the system processes accumulated memory and restructures it. Near duplicate memories merge. Confidence on unreinforced details decays. Patterns get extracted from recurring specifics. The result is that memory grows in depth more than in raw volume.

Retrieval scales with this. Rather than searching across every piece of accumulated data, retrieval operates on a structured knowledge graph that grows in quality, not just quantity. Adding more years of context makes the system smarter, not slower.

There are limits. We're not claiming infinite scale without tradeoffs. But the architecture is designed for the long horizon, not the first 90 days.

The system is built for native multilingual cognition, not translation.

There's a meaningful difference. Translation based multilingual systems route everything through English internally, then translate the result. Nuance gets lost. Cultural context disappears. Meaning that lives in specific words gets flattened.

Anant operates natively in multiple languages, with particular focus on contexts where code mixing happens within sentences rather than across documents. A user shifting between languages in the same conversation, including transliterated forms, doesn't break the cognitive understanding. The system extracts entities, relationships, and beliefs from the actual language used, not from a translated approximation.

This matters for cognition, not just communication. How relationships get named, how family structures are described, how emotion gets expressed, all carry meaning that gets lost when forced through English first. We're building memory that respects the language people actually think in.

English works well. Hindi works well. Other languages are in active development, with the architecture designed to extend rather than retrofit.

These are the right questions to ask, and they shape how we build.

The architecture is privacy first by design, not by disclaimer. For institutional and enterprise deployments, Anant runs entirely inside the customer's own infrastructure, on their servers, their network, under their control. The system operates where they keep it. No data moves elsewhere unless they choose to send it.

For individual users, the same principle applies in spirit. Memory belongs to the person it's about. Users can see what's remembered, understand why, and remove what they don't want stored. The system is designed to be transparent about its own contents, not opaque.

The right to forget is built in. Memories can be removed explicitly, downgraded in confidence, or marked as superseded by new information. We treat removal as a first class operation, not an afterthought.

Auditability matters as much as deletion. Every piece of remembered context traces back to its source, whether that is the conversation, document, or signal that produced it. Users and administrators can inspect what's in memory and where it came from. Memory you can't audit is memory you can't trust, and we know that.

We're approaching this as an architectural problem, not a policy problem. Technical commitments are stronger than promises. Build it right, and trust follows.

No, and the question itself reveals a misunderstanding about what we're building.

A wrapper repackages an existing system and adds a thin layer of convenience. We're doing something architecturally different.

We use open source language models as a substrate. They are the language layer of our system, the part that generates responses and processes natural language. The cognitive architecture sitting on top of them, including how memory is structured, how beliefs are tracked, how knowledge consolidates over time, how retrieval reasons across multiple parallel pathways, is our own work.

Think of it this way. A car uses an engine. The engine is critical. But you wouldn't call the car "a wrapper on the engine." The car is everything around the engine that turns raw power into useful transport, including the chassis, the transmission, the steering, the braking system. The engine matters. The architecture around it matters more for what the system actually does.

We use open weight models because they let us deploy cognitive systems anywhere, including inside customer infrastructure where foreign cloud APIs cannot operate. The cognitive work is independent of which language model sits underneath. We could swap the underlying model tomorrow and the architecture would continue to function. The intelligence is in the architecture, not in the substrate.

Calling this a wrapper is like calling Tesla a wrapper on electric motors. Technically the motors exist. Strategically that misses what's actually being built.

This is a fair question, and one we've heard from researchers who've seen too many startups misuse neuroscience as marketing.

The honest distinction is between metaphor and implementation.

Metaphor sounds like "our system has neurons just like your brain." That kind of language is everywhere in AI marketing and means almost nothing. It borrows the prestige of neuroscience without committing to anything the research actually says.

Implementation is different. It means taking specific findings from cognitive science and turning them into specific architectural decisions, then being able to point to where each finding shapes how the system actually behaves.

A few examples from our work.

Tulving's distinction between episodic and semantic memory shows up as different storage and retrieval patterns for specific events versus general knowledge. Episodic memories are tied to time and context. Semantic memories are abstracted and timeless. We treat them differently, the way the research suggests we should.

Complementary learning systems theory, from McClelland and colleagues, shapes how our consolidation cycles work. The hippocampus stores specific episodes rapidly. The neocortex extracts patterns slowly during downtime. Our system mirrors this with rapid memory ingestion during conversation and offline pattern extraction during consolidation cycles.

Ebbinghaus's empirical work on forgetting curves shows up in our confidence decay. Memories that aren't reinforced lose confidence on a curve that approximates what Ebbinghaus measured experimentally in 1885. The shape of the decay isn't arbitrary.

These aren't metaphors. They're design decisions traceable to specific research. The architecture genuinely changes based on what cognitive science has learned.

That said, we're not claiming to have implemented a brain or replicated biological cognition. We're claiming that when cognitive science offers specific architectural guidance, we follow it rather than ignoring it. That's the difference between using research and namedropping it.

We're a research lab in private alpha. Public papers come when results are mature enough to share rigorously, not before.

What exists today is a working cognitive system in deployment with early partners, a documented architecture, and an active research agenda spanning nine areas of next generation AI cognition. Our architecture page describes how the system is built. Our research page outlines the broader direction.

For people who want depth before formal publication, including investors, technical collaborators, and prospective partners, we welcome direct conversations. Architecture walkthroughs, demos, and technical discussions happen regularly. Email us. We'd rather show the work to people who matter than publish prematurely.

Research that points toward a new generation of AI deserves to be done carefully. We're choosing depth over speed.

The history of foundational AI breakthroughs has rarely been written by large institutions.

Transformers came from a small team at Google. The original GPT architecture came from a research lab smaller than many expected. The most consequential ideas in cognitive architecture have often emerged from focused groups working on specific bets, not from the largest organizations.

We are three founders working on a specific architectural direction, building AI systems that think and remember the way biological intelligence does as a path toward more genuinely intelligent machines. We've been building production AI systems for years. We've studied the cognitive science our work draws from. We have a working system in private alpha and an active research agenda.

Our small size is not a weakness. It's the reason we can move fast on a specific bet that larger labs aren't prioritizing. Anthropic and DeepMind are doing important work on frontier models. They are not the only labs that will shape the next decade of AI. The architectural layer above the model, meaning how AI represents, remembers, and reasons, is wide open. That's where we're working.

Judge the work. We expect to be measured against what we build, not who's building it.

We're working on cognitive architecture, which is one of several research directions that point toward more genuinely intelligent AI. Whether the result counts as AGI depends on definitions that the field hasn't settled.

What we're convinced of is that the current generation of AI, despite remarkable capabilities, is missing something fundamental. These systems generate impressive outputs but lack persistent memory, structured belief, temporal reasoning, and the kind of accumulated understanding that biological intelligence builds over time. They are powerful tools that don't yet think.

The question of what comes next has multiple serious answers. Some labs bet on scaling existing architectures further. Some bet on new training approaches. We bet on cognitive architecture, on building systems whose representations and reasoning processes mirror what we know about how minds actually work.

If that path leads to something the field eventually calls AGI, that would be a significant outcome. If it leads to something more useful but less universal, that's also fine. We're not optimizing for a label. We're working on the architectural questions that we think matter most for the next decade of AI capability.

The honest framing is that we're a research lab pursuing a specific bet about what intelligence requires. The outcome of that bet is what we'll be judged on, not the ambition of the framing.

A smart engineer working alone for six months could replicate the obvious parts of any system, including ours. That's true of almost everything in software. The question is whether what they replicate matches the depth of what exists.

The visible parts of Anant include vector storage, graph relationships, retrieval, and language model integration. A capable engineer could rebuild surface level versions of these in months.

The non obvious parts are what compound over time. How extraction handles ambiguity in real conversations. How belief states transition based on accumulated evidence. How consolidation balances merging similar memories with preserving useful distinctions. How retrieval ranks results when channels disagree. How deployment patterns work for institutional contexts. How the system handles the long tail of edge cases that appear in real usage.

These details came from building, deploying, testing, breaking, and rebuilding the system over time with real data. They aren't published in a paper. They aren't visible from the outside. They're the difference between something that demos well and something that works.

Our moat isn't a single algorithm or a patent. It's the accumulated depth of decisions, tradeoffs, and learnings that come from being focused on one thing for a long time. That depth keeps growing. Every month of operation adds to it. Every customer surfaces edge cases that improve the system. Every research direction we pursue compounds with what already exists.

If a competitor wants to replicate the system in six months, they'll get the visible parts. They'll spend years catching up to the rest, and by then we'll have moved further. That's how research labs build durable advantage.