Learn from real interactions.
Improve behavior. Stop repeating mistakes.
Emend turns user corrections, failed paths, and successful outcomes into behavior changes your agents reuse — each one visible, and revocable.
The user asked
“There's a $49.99 charge on my card I don't recognize.”
Without Emend
Missed the second charge
The agent replied
“I've refunded the $49.99 charge.”
What happened next
The user came back 10 minutes later. “There's also a $9.99 one.”
Cost: 2 conversations
With Emend
Caught both charges at once
The agent replied
“I found two unfamiliar charges — $49.99 and $9.99. Refund both?”
What happened next
Nothing. The user was already done.
Cost: 1 conversation
What Emend learned in between
- 1Search the full window of recent charges before resolving any single one.
- 2Present everything unfamiliar in one message, and ask whether to refund together.
Let your coding agent integrate Emend.
Start with the portable skill, or wire the same retrieve-and-publish loop through Python, REST, or the CLI.
Give this prompt to Codex, Claude Code, or Cursor.
Follow the Emend quickstart to integrate Emend into my agent:https://www.emend.online/docs/getting-started/quickstart Run this from your agent application's repository. The guide coversthe existing lifecycle, implementing the Emend loop, and verifyingthe changed path.Static agents, made self-improving.
The lessons are already in your logs. Four things Emend does with them.
Self-improvement loop
It keeps learning, not just once.
Every conversation your agent has feeds back in. Emend notices what keeps going wrong, turns the repeats into a learning, and retires older learnings once newer conversations contradict them. When your policy or your product changes, the agent changes with it instead of staying stuck on what was true the day you set it up.
Learned in March
- Refunds allowed within 30 days
- Confirm the order before refunding
Replaced in June
- Refund window is now 14 days
- The March learning is no longer used
Self-tuning learnings
Every learning is tuned by the evidence it produces.
Emend watches how a learning actually performs once your agent starts using it — the sessions it improved, and the ones it did not — and revises it from those cases. It is a continuous, research-backed optimization process, so a learning gets better the more it is used rather than staying whatever it was when first captured.
Evidence from new sessions
- Where the learning helped
- Where it fell short
The revised learning
- Rewritten from those real cases
- Validated before it counts
Evaluation & impact
Know whether it actually helped.
Improvement is measured against what matters to the people using your agent: was the problem solved, did they have to correct it, did it end up with a human. You define what success means, Emend scores conversations against it, and every result traces back to the learnings behind it.
Metrics that matter
- Was the user's problem solved?
- Did they correct it, or need a human?
And how far to trust it
- Which learnings did the work
- The methodology stated, so you can check
Review & control
Every learning is auditable, and under your control.
Open any learning to see what it holds and the evidence behind it. Rewrite it, approve it, reject it, or delete it — a rejected learning stops being used straight away. Want your agent to use only what you have signed off? That is one setting.
Auditable
- Check all recent charges first
- Traceable to the evidence behind it
Controllable
- Rewrite it, or approve it as is
- Reject or delete, and it stops being used
What you are wiring into.
One loop. Your agent publishes what happened, Emend extracts what to do differently, and the next run reads it back. Nothing is retrained.
Your Agent
AI-powered assistant
Emend
Learning & evaluation
Learning Store
Persistent context
Simple integration
Wrap your existing LLM calls with a lightweight SDK — no agent rewrite needed.
Actionable signals
Triggering conditions and actionable feedback are extracted from user corrections automatically.
Evolving intelligence
Learned behaviors consolidate, and conflicts between them resolve, over time.
Precise context injection
Only the relevant signals are retrieved at the moment of inference — which keeps token cost down.
Built different from the ground up to create agents that actually learn.
Autonomy through reflection
Agents think back on their performance and optimize their own logic — not just retrieve stored facts.
Full extraction control
Tunable extractors that look for business-specific signals — a churn signal in customer service, a syntax error in a coding agent.
Safe behavioral evolution
Every learned behavior is scored against a control response before you rely on it, and rejecting one revokes it from retrieval immediately.
Low-cost learning extraction
When a user corrects your agent's tool usage or process, Emend extracts that as actionable feedback for all future similar scenarios.
Data rights
Your users can have their data exported or permanently erased on request. Bring your own storage or cloud to meet your privacy requirements.
Conflict resolution
A background process de-duplicates and resolves conflicting learning signals, preventing behavioral drift and learning rot.
Traditional memory layers, compared with Emend — capability by capability.
Traditional memory
What memory tools store
Emend
Behavioral learning platform
Stores what users said
Learns how the agent should act
You read the logs to find the problem
The correction and its trigger are captured together
Facts a model may or may not retrieve
Rules you can read, in a queue you control
No way to tell whether a memory helped
Responses scored against the un-augmented one
No way to undo a bad memory
Reject one and it drops out of retrieval
“What did the user say?”
“How should the agent behave differently next time?”
Your data, your keys, your cloud.
Different teams draw the line in different places. Emend runs anywhere from fully managed to fully self-hosted — and the API your agent calls never changes.
Managed
Nothing to operate. We run the service and your organization gets its own isolated schema — the right default when infrastructure is not where you want to spend the year.
BYOK
Use your own provider credentials: OpenAI, Anthropic, DeepSeek, Qwen, xAI and more, or a custom endpoint. For teams with negotiated model contracts, their own rate limits, or a policy about which providers may see their traffic.
Your database
We run the service; the learning data sits in a Supabase project or Postgres instance you own. For teams that need to query, back up and retain it under their own controls.
BYOC
Emend runs inside your own AWS, GCP or Azure account. For regulated environments where the requirement is simply that nothing crosses the account boundary.
Self-host
You run all of it, single-tenant, against a database you own, with no connection back to us. For air-gapped deployments and teams that need to be independent of a vendor's uptime.
Learn from real interactions.
Improve behavior. Stop repeating mistakes.
Emend turns user corrections, failed paths, and successful outcomes into behavior changes your agents reuse — each one visible, and revocable.