Governed memory for AI

Governed memory for agents.

Fjard serves approved replies and decisions before a turn reaches your model. Hits are instant and audited; spills go to your model and come back as proposals.

Get API keyComing soon Read the docs

Request lifecycle

Simulated request lifecycle. Each turn enters the System One decider, which costs $0.0001 per turn. Seven in ten are hits above confidence 0.9 and are served from the graph as approved replies in 0.34 seconds. The rest spill to your model, which adds 1.82 seconds and $0.004, become proposals queued for human review, and return to the graph once approved.
served from graph 10sent to your model 3approved back 2model spend avoided $0.039Simulated
Proxy
client = OpenAI(
    base_url=FJARD_PROXY_URL, api_key=YOUR_MODEL_KEY
)  # Python

How it works

Define once. Approve. Serve.

  1. 01

    Generate a graph

    Build a versioned graph from your docs, transcripts or agent traces.

  2. 02

    Set the approval gate

    Humans or your trust policy approve the nodes that may be served.

  3. 03

    Serve and improve

    Serve confident hits at the edge and turn spills into proposals for review.

For agents

Cache the decision. Keep control.

A node can hold a tool call and its arguments, so repeated decisions skip the model round trip.

Your agent. Its boundaries.

Use one graph per agent, or share a graph with per-node scope controlling which agents may use it.

Choose who can write to memory.

Strict
Humans approve every node before it can be served.
Supervised
The agent drafts proposals. Humans approve them in batches.
Autonomous
The agent commits to a labeled auto tier after a verifier check, with full versioning and one-click rollback.
TypeScript 
const d = await fjard.decide({
  graph: "support-agent",
  agentId,
  state,
})

// { served: "vetted" | "fallback", payload }

API shape, subject to change.

Beyond a semantic cache

Memory with an approval gate.

Reuse is a governance decision, not just a similarity score.

Approval before reuse.
Every hit was approved by a human or a trust policy you set. You decide what enters memory.
Human or policy approved
Context changes the answer.
A turn means something different depending on where the conversation or agent is. Match the path, not just the words.
Conversation and agent context
Misses enter a review queue.
Spills become proposals. Unchecked model outputs never silently enter the approved graph.
No silent cache pollution

Trust & governance

Every change has an owner.

Set the rules per graph. Trace what was approved, by whom, and when.

Versioned graphs
Track changes and roll back to a previous graph version.
Immutable published versions
Publish a fixed version so serving behavior stays tied to an identifiable release.
Approval audit trail
Record who approved what and when, with the policy and graph version behind each hit.
Trust policies per graph
Choose Strict, Supervised or Autonomous to control who may add nodes.
Per-agent scope
Limit which agents can use each node in a shared graph.
Bring your own key
Keep your model and key behind your gateway.
Per-org isolation
Keep each organization’s graphs and access boundaries separate.
Export anytime
Export your graph as plain JSON. Your memory stays portable.

Product design preview. These controls describe the intended trust model; availability and implementation details will be documented before launch.

Explore the trust model

The console

See what memory takes off your model.

support-agent / Production previewMock console · All values illustrative
Hit rate
78.4%
Turns served from the graph
Spend saved
$142.60
Estimated model cost avoided
p50 latency
340 ms
Median end-to-end hit latency
Proposals waiting
12
Ready for a human to review

Hit rate over time

Last 7 days
90%70%50%30%

Spills by node

NodeSpills
custom_region48
billing_exception31
order_lookup19

Example data only. Not measured product results or performance guarantees.

Your stack stays yours

Your decider. Your model.

Choose how to match and where to spill. No vendor lock-in. Export your graphs as plain JSON.

Match with a decider

  • Jev
  • Other System One models
  • Embeddings
  • LLM router

Spill to your model via gateway

  • Anthropic
  • OpenAI
  • Workers AI
  • Anything behind your gateway

Use a fast, non-generative classifier by default, or bring your own routing strategy.

Use cases

Repeat the right behavior.

Agent tool routing
Serve vetted tool calls and arguments for recurring decisions.
Long-running agents
Keep repeated actions on approved paths as tasks continue.
Support deflection
Answer recurring questions with replies your support team approved.
Sales objections
Keep pricing explanations and product claims consistent.
Regulated-industry bots
Serve covered language that legal and compliance teams have signed off on.
Advocacy & public information
Publish reviewed guidance and bring new questions back for approval.

Pricing

Start with a graph. Scale with usage.

Free tier, usage-based plans and enterprise options. Limits and rates will be published before launch.

Free tier
Get started with a graph and explore your first integration.
For your first approved replies
Usage-based
Scale your usage as more conversations pass through Fjard.
For growing chatbot traffic
Enterprise
Contact us to discuss deployment, governance and review requirements.
For organization-wide needs

Enterprise contact details coming soon