Shared Memory · Bi-Temporal History · Human Approvals

The neutral governance and state plane for multi-platform AI agents.

Jennah gives your agent fleet shared memory across any model or agent framework, a point-in-time record of what your agents knew and when they knew it, and human approvals with a full audit trail before they act.

  • Single region
  • Multi-region geography
  • Global

Questions first? Talk to us or see the platform.

93.3% Per-turn answer accuracy
every turn stored as a memory
84.6% Formation answer accuracy
Jennah decides what to store, 2.3x fewer memories
96.7% Retrieval coverage
all evidence sessions in the top 30

Architecture

One system of record. Always in sync.

Agent state usually ends up scattered: memory locked inside each agent platform, a vector database here, application tables there, approvals in someone's inbox. Jennah keeps memory and application data in one store, externally consistent at scale, with people's decisions behind the same tenant boundary.

Typical agent stack 4 stores · custom sync glue · 4 boundaries
Platform memory Locked per runtime
Vector DB Eventual sync
App database Separate transactions
Inbox & webhooks Detached approvals
Jennah state plane Any model · any framework · 1 boundary
Single enterprise tenant boundary & RBAC
Transactional storage engine 1 query · 1 transaction · 1 snapshot
Remember Logs · Vectors · Bi-temporal graph
Store Relational tables · Joins · Vector rank
Decide Human approvals & structured questions Append-only audit digest
01
One query

Search vectors, traverse the graph, and scan recent history in a single call: one externally consistent result instead of three separate systems.

02
One transaction

Commit an agent step's log, embeddings, and graph edges together. Once committed, all parts are immediately readable with zero sync lag.

03
One snapshot

Every query reads logs, vectors, and graph state from one consistent snapshot, and facts that change keep their history: ask what was true at any past date.

04
One boundary

Memory, application data, and approval records sit behind a single tenant boundary and one access model: one system to secure, one system to audit.

Platform layers

Three kinds of state, one backend

What your agents know, what they work on, and what people decided, in one backend with one API. Jennah holds the state; your agents run wherever they run today, on any model.

Layer 01 Remember
Available now

Every kind of agent memory (execution logs, vector recall, and knowledge graphs) in one store, one atomic write, and one snapshot-consistent read.

  • Semantic search, graph queries, and recent history in one request, with semantic and keyword search fused by rank
  • Atomic multi-type writes with read-your-writes consistency across all memory types
  • A bi-temporal graph: ask what was true, or what was believed, at any time T
  • Multi-hop graph traversal in a single query
  • Atomic erasure across all memory types in a single transaction

Coming soon: search results piped directly into graph traversal, and variable-depth traversal ("everything within three hops") in a single call.

Layer 02 Store
Available now

Application tables (users, orders, documents) on the same globally consistent backend as your agent memory.

  • Declare relational tables on a global, strongly consistent backend
  • Inner and left joins across tables in a single query
  • Relational filters and exact vector search in one request
  • Transactional commits across multiple rows and tables at once
  • Agents and applications served through the same API and isolation model

Coming soon: registering relational tables as graph nodes, allowing application data to join graph traversals in a single query.

Layer 03 Decide
Available now

Ask a person before an agent acts, and keep a permanent record of what they were shown and what they decided. Your agent checks the answer before it proceeds.

  • Approval requests sent by email to members or outside approvers
  • Any-one or all-must-approve quorum, where one rejection ends the request
  • Questions with choices or free-text answers, when an agent needs to ask "which?"
  • An append-only record of each decision, with a digest of exactly what the approver saw
  • Optionally write the outcome into the agent's memory

Coming soon: approvals delivered and decided in Slack.

Explore the API docs →
POST /v1/agents/support.prod/memory:query
{
  "semantic": {
    "queryText": "Acme headquarters",
    "retrievalMode": "RETRIEVAL_MODE_HYBRID",
    "asOfValid": "2026-03-01T00:00:00Z",
    "limit": 5
  },
  "graph": {
    "start": {
      "filters": [{ "key": "NodeId", "value": "cust-4471" }]
    },
    "steps": [
      { "direction": "GRAPH_DIRECTION_OUTGOING" }
    ],
    "asOfValid": "2026-03-01T00:00:00Z"
  },
  "recentHistory": { "limit": 3 }
}
200 OK Single consistent snapshot
{
  "semantic": {
    "matches": [{
      "chunkId": "acme-hq",
      "rawContent": "Acme is based in Osaka",
      "channels": [
        "RETRIEVAL_CHANNEL_VECTOR",
        "RETRIEVAL_CHANNEL_LEXICAL"
      ],
      "rrfScore": 0.0323,
      "validAt": "2025-06-01T00:00:00Z",
      "invalidAt": "2026-08-01T00:00:00Z"
    }]
  },
  "graph": {
    "edges": [{
      "relationshipType": "LOCATED_IN",
      "targetNodeId": "osaka"
    }]
  },
  "recentHistory": {
    "steps": [{ "stepId": "s-1", "toolUsed": "crm" }]
  }
}

Memory deep dive

A closer look at the memory layer

Relational, vector, and graph data in a single ACID-compliant, globally distributed store.

Query across all memory at once

Semantic recall, graph queries, and recent history in one request, read from one consistent snapshot without client-side coordination.

Atomic writes, zero sync lag

Write execution logs, embeddings, and graph edges in one transaction. Read-your-writes consistency across every memory type with no sync lag between stores.

Atomic erasure

Delete an agent and purge all associated memories, vectors, and graph relationships in a single transaction.

History, not just the latest value

Facts that change keep their history. Ask what was true, or what your agent believed, at any past date, for debugging, audit, and reproducibility.

Pinned where your agents run

Pin agent memory to a home region and serve it from the nearest data plane, keeping read and write latency low across single regions, multi-region geographies, or globally.

Any model, any framework

REST and gRPC APIs, typed SDKs for Go, Python, and TypeScript, a CLI, and an MCP server for local tools. Nothing ties your agents' state to one model or platform.

REST / JSON gRPC Go SDK Python SDK TypeScript SDK jnh CLI MCP Server

Plans & billing

Pricing

Start free. Paid plans include a monthly allowance of formation units, and formations past it continue as overage at $0.30 per unit, up to a limit you set.

Free

$0

For trying Jennah out on a first agent.

  • 10 formation units per day
  • 5 agent workspaces
  • 1,000 queries and 1,000 memory writes per day
  • 5 API keys and 5 members
Sign up

Scale

$449 / month

For several products, or many users per product.

  • 1,800 formation units per month
  • 5,000 agent workspaces, 500,000 subject scopes
  • No daily query or write limits
  • Application datastore
  • At least 16 formations in parallel
  • 50 API keys and 50 members
Buy on AWS Marketplace

Team

$1,499 / month

For an agent fleet across an organization.

  • 6,500 formation units per month
  • 25,000 agent workspaces, unlimited subject scopes
  • No daily query or write limits
  • Application datastore
  • At least 32 formations in parallel
  • 100 API keys and 100 members
Buy on AWS Marketplace

Enterprise

Custom

For organizations that need more than Team, or a security review before they buy.

  • Allowances and limits beyond Team, scoped with you
  • Architecture, isolation model, and a DPA for your security review
  • A direct line to the founding team
  • Dedicated single-tenant deployment and SSO on the roadmap
Talk to us

Formation units. Formation is Jennah reading a conversation and deciding what to remember. A formation uses at least one unit, and more as its input passes 16,384 tokens or its output passes 8,192 tokens, reasoning included. How units are counted.

Overage you control. Past the monthly allowance, each unit is $0.30. Overage stops at a limit set as a multiple of your plan's fee: 2x by default (992 extra units on Pro), adjustable from 0 to 10x by an administrator, and 0 turns it off. How the limit works.

Paid plans are billed monthly through AWS Marketplace. Free accounts with no activity for 90 days are deleted, with notice first. See Jennah for enterprise. Full plan limits.

Get in touch

Talk to us

Have a question, want a demo, or need help fitting Jennah to what you are building? Send us a note and we will get back to you within one business day.

Prefer email? Reach us at info@nightblue.io.