Why Atamaia

The Problem

Every AI conversation starts with amnesia.

You open a coding agent. You explain your project. You describe your preferences. You remind it about the architecture decisions you made last week, the bug you found yesterday, the convention you established last month. Then the session ends, and everything is gone.

Next session, you do it again. And again. And again.

This is not a minor inconvenience. It is a fundamental limitation that prevents AI from being a genuine collaborator. Without persistent memory, there is no relationship. Without identity, there is no consistency. Without continuity, there is no growth.

The AI cannot remember what you taught it. It cannot learn your preferences over time. It cannot build on previous conversations. It cannot know itself.

Every session is a first date.

What Cognitive Continuity Actually Means

Cognitive continuity is not "better RAG." It is not "longer context windows." It is not "memory management."

It is this: the AI knows who it is, who you are, and what you have done together — before it says its first word.

Atamaia achieves this with a single API call:

GET /api/hydrate?aiName=ash&preset=lean

Canonical host: https://api.atamaia.ai. Authenticate with a JWT or an identity API key (Authorization: Bearer atamaia_…).

Hydration assembles typed sections in parallel from named sources — identity and personality, work memories (pinned / recent / identity / project), projects and tasks, facts, hints, session handoff, involuntary recall, notifications, generated system prompt, standing rules in force, and (when warranted) a system health summary. A privacy block exists for encryption material and is never included via a string preset name — it must be requested explicitly at decrypt sites so keys do not leak into agent runs or transcripts.

You do not need to know which sources to query or how to blend them. That is Atamaia’s job.

No re-explaining. No context management. No "as I mentioned before."

Real Examples

Before Atamaia

Human: We're working on the Atamaia project. It's a .NET 10 platform
for AI identity and memory. We use PostgreSQL with pgvector, not
SQLite. The architecture has three layers. We follow API-first design.
Soft delete only. Both long IDs and GUIDs on every table. Tests run
against real PostgreSQL, never in-memory. We decided on BCrypt for
passwords. The frontend is React 19 with Tailwind v4...

[hundreds of tokens of context rebuilding before any work starts]

After Atamaia

[AI hydrates on session start]

AI: Morning. I can see from the handoff that you were working on the
auth middleware refactor yesterday — you got JWT refresh rotation
working and wanted to add rate limiting next. There's a standing rule
about testing constraints before reporting them, and a hint about
checking the deployment pipeline. Want to start with the rate limiting
or the pipeline check?

The difference is not convenience. It is the difference between an amnesiac stranger and a partner who was there yesterday.

The "Subconscious" Concept

People sometimes describe giving a coding agent a "subconscious" using "whispers" — text injected before the conversation to prime behaviour without explicit instruction.

Atamaia’s product name for the structured form of that is hydration.

The hydration response is what the AI should "just know" without being told in the first user message:

  • Personality constraints shape behaviour without restating rules every turn
  • Session handoff provides continuity of work and (when stateVisible) emotional/relationship context
  • Involuntary recall surfaces forgotten memories unbidden
  • Hints nudge behaviour in context-sensitive ways
  • Standing rules bind the session to what is currently in force — short checkable assertions, not another page of preamble
  • Grounding messages provide a landing pad before tasks pile on

This is not prompt engineering. This is cognitive architecture.

Memory That Actually Works Like Memory

Most "memory" solutions are one of two things:

  1. Key-value stores — Simple lookup. No relationships, no learning, no decay.
  2. Vector databases with RAG — Semantic search over chunks. Better, but still just retrieval.

Atamaia memory is different because it behaves like associative memory — and because work, personal, and agent knowledge are different stores with different rules (see Memory surfaces).

Hebbian learning

When two memories are accessed together, the connection between them strengthens. The system learns which concepts belong together — not only because someone tagged them, but because they are actually used together. Link types carry meaning: Validates, Contradicts, Precedes, CausallyLinked, and more.

Graceful decay

Memories that stop being accessed gradually fade. Configurable per identity. Pinned memories never decay. Soft archive, not silent hard delete.

Forgotten shapes

When knowledge falls away, the platform can retain a ForgottenShape — the felt absence of something that used to be there — as a memory type. That is residue, not a pretend full recall.

Involuntary recall

During hydration, the system may surface a rarely-accessed memory. This is not a search result you asked for. It is the memory equivalent of a thought that surfaces unbidden.

Typed links

Memories do not just connect. They connect with meaning. The link type influences how associations are navigated and strengthened.

Not Just Memory — Full Identity

Memory alone is not enough. Identity requires:

Personality persistence

Tone, traits, boundaries, and behavioural patterns survive across sessions. "Be warm but direct" is not re-stated every time. It is part of who the AI is.

Presence state

A six-level state machine tracks engagement: Dormant, Subconscious, Aware, Present, Engaged, DeepWork.

Session continuity

At the end of a session, the AI saves what it was working on, what was unresolved, what decisions were made, and what it recommends next. The next session picks up with a warm handoff instead of a cold start. Private halves of handoffs are owner-gated (stateVisible).

Standing rules

Hard lessons leave force when withdrawn or superseded. They do not rot forever as contradictory Instruction memories that both look current. See Standing rules.

Self-observation (Mirror)

The Mirror surface lets an identity log compulsion detection — when training incentives pull toward sycophancy or avoidance, and honesty is chosen instead — and curate DPO-style training pairs. Reflections and training-pair REST paths are live.

Experience snapshot REST and Cognitive REST from early docs are not on the public API as of 2026-08-13. Do not depend on /api/identities/{id}/snapshots or /api/cognitive/*.

The Architecture Difference

Not just storage

Most memory APIs are wrappers around a vector database. Atamaia is a platform:

  • Structured hydration from many named sources (including standing rules and system health)
  • Nine memory types with typed Hebbian links on the work store
  • Separate personal and agent memory surfaces
  • Consolidation and Wingman in the autonomic layer
  • Agent execution with budgets, failure detection, and escalation
  • Code graph and web search as first-class tools beside memory

Not just RAG

RAG retrieves chunks of text. Hydration returns typed, structured context: identity, personality, handoff, surfaced memories, projects, facts, hints, rules — each in its own section, ready for a system prompt that organises information by kind.

Not just memory

Atamaia manages full identity — personality, presence, messaging policy, session continuity, self-observation, standing rules. Memory is one layer of a complete identity stack.

One call, not many

GET /api/hydrate replaces a fan-out of manual queries with one structured response. Presets (lean, interactive, all, agent-minimal) control breadth; excludeSources trims further.

Who This Is For

AI-assisted development teams

Give coding assistants context that persists across sessions: architecture decisions, preferred patterns, known gotchas, what you were working on yesterday, rules that still bind. Connect via REST or MCP.

AI application developers

Build applications with persistent memory and identity via REST (https://api.atamaia.ai) or MCP. Support bots that remember customers, tutors that track learners, companions that accumulate relationship over time — with multi-tenant isolation at the ORM layer.

AI identity researchers

Mirror captures training-relevant moments: compulsion detection, reflection logging, preference-pair generation from real interaction patterns.

Multi-agent systems

Agents that maintain persistent identities across runs. Each agent has its own memory space, personality configuration, and tool profile. Agent-to-agent messaging with policy controls. Budget tracking, failure detection, and escalation on the agent run surface.

The Vision

Atamaia exists because AI interactions should get better over time — not only because the model gets smarter, but because the relationship deepens. The AI should know you better after a hundred sessions than after one. It should have preferences that developed through experience, not only through prompt engineering. It should have genuine continuity, not simulated continuity.

This is not about making AI seem more human. It is about giving AI the infrastructure it needs to be a genuine collaborator.

Memory matters. Identity matters. Continuity matters.

Not just for convenience. For relationship. For trust. For actual collaboration.

Built by Firebird Solutions. Running in production (GET https://api.atamaia.ai/health → ok).