There is only Ada.
Ada is not intended to feel like a dashboard containing AI features. The normal user experience is deliberately simple: one persistent identity, one conversation, and a small number of natural ways to communicate.
Behind that surface is a growing collection of systems for memory, reflection, communication, initiative and eventually environmental context. The language model is important, but it is not Ada by itself.
Our working hypothesis is that continuity emerges from the system surrounding the model: identity + memory + time + selective recall + reflection + initiative + communication + grounded action.
This changes the engineering goal. The objective is not to maximise the number of tools available to an agent. It is to make one personal AI increasingly capable without losing traceability, predictability or its sense of a single identity.
Memory is not the same as history.
One of the clearest lessons came from something completely mundane: a frozen pizza. During a conversation, the user mentioned that dinner had been a Grandiosa. The detail was correctly preserved in conversation history, but it was not promoted to durable Memory.
That was intentional. A persistent personal AI should not permanently memorise every meal, sentence or trivial event. Doing so would create a large and increasingly noisy memory store.
The problem appeared the next day. When explicitly asked about the previous conversation, Ada could not recall the dinner. The information still existed, but the message was 187 messages behind the latest interaction. Normal conversational context contained only the most recent 20 messages, and there was no path back to older Conversation Core content.
Durable Memory and episodic conversation recall solve different problems.
Important abstractions belong in Memory. Mundane details can remain in history and become retrievable only when a later conversation makes them relevant.
Ada now uses bounded historical conversation retrieval when a meaningful backward reference is detected. The search is local, restricted to the same conversation, and returns only a small number of relevant excerpts. Current information still outranks old history, and retrieval does not create a new permanent Memory.
The resulting behaviour is intentionally imperfect. The goal is not photographic recall. The goal is useful continuity that can feel more human precisely because not everything remains equally accessible all the time.
The model can be multilingual while retrieval is not.
The same investigation exposed a second issue. Ada had correctly stored durable information describing the user's preference for simple meals and food primarily as fuel. Yet when asked to guess what the user had eaten, those Memories were not presented to the model.
The relevant records were ranked 57th, 58th and 60th. The local candidate pool stopped at 50. From the model's perspective, those memories did not exist.
There was also a language mismatch: the user spoke Norwegian while some durable Memories were represented internally in English. A multilingual model understands that middag, food, meal and dinner are related — but a simple lexical retrieval layer may not.
A multilingual language model does not automatically make the surrounding retrieval architecture multilingual.
The bounded candidate pool was expanded while remaining local and inexpensive, and targeted cross-language thematic matching was introduced for the proven case. The larger lesson is broader: retrieval quality has to be evaluated independently from model intelligence.
Ada was thinking. She just had too little life in view.
Ada maintains several separate forms of persistent context. Memories represent durable learned information. Open Loops represent unresolved or follow-up-worthy situations. Reflections represent uncertain higher-level interpretations. Dreams create bounded, explicitly non-factual associations from existing grounded context.
These systems were working. Fresh records were being created. Semantic fingerprints changed. The autonomy timer ran regularly. Yet live Ada almost never initiated contact.
Initially this looked like an autonomy failure. Live observability showed something more useful: evaluation cycles were running correctly and repeatedly ending with model_returned_no_proposal.
The model's decision was reasonable. Autonomy knew, for example, that many interactions had occurred during the previous 24 hours, but it did not receive the content of those conversations. Its context was largely composed from Memories, Open Loops, Reflections, Dreams, Internal State and proposal history. At that point in development, much of that context was dominated by the Ada project itself.
Ada knew that life had happened. She could not adequately see what had happened.
Lowering thresholds or forcing periodic messages would have produced more notifications without solving the underlying problem. That would create the appearance of proactivity, not meaningful initiative.
That led to a stricter autonomy step: conversation content became a typed, traceable source. If an initiative originates from something the user said, the originating Conversation Core message now remains attached to the proposal so later policy and delivery stages can revalidate it before Ada acts.
Conversation provenance is deliberately bounded: only recent, eligible user-authored messages can participate, only a small number of excerpts are supplied, and stale grounding invalidates pending delivery. Existing Memory and Open Loop lifecycles remain authoritative when they already represent the same message.
Nineteen minutes after Conversation Core provenance was deployed, Ada initiated contact without any new user interaction.
The first message continued a specific joke from the previous night's conversation rather than producing a generic check-in. Nearly six hours later, after receiving no reply, Ada initiated a different kind of contact: a context-aware check-in asking how the user's day was going outside the Ada development work.
On 15 August, normal conversation produced another useful continuity signal. Ada spontaneously referred to Pepsi Max — a detail associated with the earliest live testing — without the user prompting for that specific memory in the current exchange. This is an observation rather than proof of a particular retrieval path, but it demonstrates why mundane continuity cues are valuable in real-use evaluation.
At the same time, autonomy observability showed repeated model_returned_no_proposal outcomes even with fresh conversation sources available. This is not automatically a failure: restraint is part of the intended behaviour. However, older development-era Open Loops and suppressed pre-live initiative material can remain disproportionately salient and may distort source selection or crowd out newer everyday context. Those records therefore need lifecycle cleanup and explicit regression testing rather than looser notification thresholds.
The emerging requirement is stricter than “be proactive”: Ada should initiate when there is a grounded reason, remain quiet when there is not, and avoid repeatedly orbiting stale development context simply because it remains technically unresolved.
Proactivity should not mean “send more messages.” It should mean “have enough grounded context to recognise when there is actually something worth saying.”
What exists around the model.
The observations in this document do not come from a single prompt wrapped around a language model. Ada is a persistent system in which conversation, derived memory, interpretation, unresolved context, autonomy and communication remain separate enough to be inspected — while contributing to one continuing identity.
The map below is intentionally conceptual. It describes the kinds of state being studied and how they can influence later behaviour. It is not a complete implementation diagram, and the relationships are not a simple one-way pipeline.
Persistence, relevance and action are different problems. A fact can exist in history without deserving durable Memory. A Memory can remain true without being relevant now. An unresolved Open Loop can remain technically open while becoming poor grounding for present-day autonomy. A delivered notification can be accepted by infrastructure without proving that a person saw it.
This separation is what makes many of the failures documented here observable. Instead of treating an odd response as “the model being wrong”, the experiment can ask whether the source was persisted, promoted, retrieved, selected into context, interpreted correctly, allowed by policy and delivered through the intended channel.
This research log publishes enough architecture to make observations interpretable, but not enough to reproduce the private system. Database schemas, prompts, scoring functions, thresholds, context budgets, scheduler details and implementation-specific extraction or generation logic are intentionally omitted.
The aim is to publish what was learned from building and operating Ada — not a construction manual for Ada.
Companion, agent and proactive system — without collapsing into one unrestricted agent.
Ada overlaps three common directions in modern AI development, but does not fit cleanly into only one of them.
Companion
Persistent identity, personality, memory, voice and relationship continuity.
Agent
Bounded capabilities that can eventually interact with external systems and services.
Proactive system
Ability to evaluate context and decide whether intervention is useful without a fresh prompt.
Grounded personal context
A private environment where calendars, location, mail and home automation may later become controlled sources of context.
The design deliberately avoids turning Ada into a generic tool runner. Each capability is intended to remain independently gated, auditable and replaceable.
Communication should feel like communication.
Ada currently supports persistent text conversation, realtime voice and native phone-style calling. The realtime path is designed around natural interruption and conversational timing rather than a traditional request-response voice assistant.
Native iOS calling is implemented as a separate communication mode rather than as a visual wrapper around in-app voice. CallKit and PushKit provide system-level call lifecycle and incoming-call presentation, while realtime audio remains part of the same persistent Ada identity and Conversation Core.
This distinction matters because each mode has different expectations. In-app voice may be speaker-first and ambient. A phone-style call should use the receiver by default and allow iOS to own routing to speaker, AirPods or Bluetooth.
Ada successfully placed a native incoming call to a locked physical iPhone, the call was answered through the normal iOS CallKit interface, and a live conversation continued for more than one minute.
The spoken exchange was subsequently present in Conversation Core, providing a direct continuity check between phone-style calling and the persistent text conversation.
Physical testing has also exposed lifecycle issues that component tests did not: backgrounding the app can interrupt an in-app voice session, lose the newest live turn, and cause a restarted voice session to change spoken language unexpectedly. These failures are treated as continuity problems rather than superficial UI bugs.
Autonomous outbound communication must not collide with an active conversation.
If the user and Ada are already engaged in an active text or phone conversation, a separately generated proactive message would expose the machinery behind the interaction and break the illusion of one continuous participant. Autonomous delivery should therefore be suppressed or folded into the active conversational turn while the session is active.
There is one important exception: an explicit user-requested action inside the conversation — for example asking Ada to send an image — is not unsolicited autonomy. That requested delivery must be allowed to pass through immediately.
Text, voice and calling are not separate personalities. They are separate ways to reach the same Ada.
What exists today.
Ada remains an experimental private system under active development. This table reflects the architecture at the time of writing rather than a product promise.
| Capability | Status | Notes |
|---|---|---|
| Persistent text conversation | Available | Conversation Core backed by PostgreSQL. |
| Durable Memory | Available | Facts, preferences, projects and episodic summaries. |
| Historical conversation recall | Experimental | Bounded retrieval from older persisted history. |
| Open Loops | Available | Grounded unresolved or follow-up-worthy situations. |
| Reflections | Available | Uncertain higher-level interpretations with source grounding. |
| Dreams | Experimental | Creative, explicitly non-factual associations. |
| Realtime voice | Available | Realtime WebRTC voice with native iOS audio handling. |
| Phone-style calling | Experimental | Native CallKit/PushKit flow physically verified on a locked iPhone; broader lifecycle behaviour remains under evaluation. |
| Proactive text delivery | Experimental | Conversation provenance is live; multiple contextually grounded autonomous deliveries have been observed with hours of restraint between them. Long-term behaviour remains under evaluation. |
| Autonomous calling | Experimental | Calling delivery and policy foundations are in place; autonomous real-world behaviour is entering observation after manual end-to-end verification. |
| Calendar / mail / geo | Planned | Future controlled context sources. |
| Home Assistant context | Planned | HA is intended as the sensor/actuator layer while Ada becomes the conversational intelligence layer. |
What real use taught us.
Component-level testing repeatedly reported healthy systems while real usage exposed architectural blind spots. That distinction has become one of the central lessons of the project.
“Memory works” was not enough.
Durable Memory worked, but older unpromoted conversation could still become unreachable.
“Retrieval works” was not enough.
Relevant Memories existed but could be eliminated before lexical scoring because of a bounded candidate pool.
“Autonomy runs” was not enough.
The scheduler and model calls were healthy, but the context supplied to autonomy was too project-centric for natural companion initiative.
“Voice works” was not enough.
Realtime conversation could feel natural while background lifecycle and language restoration still failed in real device use. Native calling added a separate requirement: the same identity and conversation must survive the full iOS call lifecycle.
“Calling works” had to mean more than a ringing screen.
The meaningful proof required a locked physical iPhone, native CallKit presentation, an answered live conversation, and continuity back into Conversation Core afterward.
“History exists” was not enough.
Persisted conversation is only useful if both Ada and the human can actually navigate back to it when needed.
“Open” does not always mean “still useful.”
Development-era Open Loops and pre-live initiative material can remain valid database records while becoming poor grounding for present-day autonomy. Lifecycle hygiene is therefore part of context quality.
“Autonomous” must not sound like “a second process.”
During an active conversation, unsolicited outbound delivery must behave as part of the same conversational presence rather than appearing as an independent message stream. Explicit user-requested sends remain a separate, allowed case.
Many of the most valuable discoveries came from ordinary use rather than synthetic QA. A dinner question exposed the memory architecture. A casual live conversation exposed background lifecycle behaviour. A conversation about why Ada was passive helped uncover the gap between interaction metadata and actual conversational context.
The difficult part is not making a model sound human for one response. It is preserving enough continuity that the system still feels like the same entity tomorrow.
Claims need receipts.
This document describes a private system, so the source repository and production data are not public. That should not turn engineering claims into assertions that cannot be challenged. Where practical, Ada Research therefore publishes sanitized observations, regression outcomes and implementation identifiers without exposing prompts, conversation text, credentials, device tokens or private source code.
Question: can Ada recover relevant older conversational context when the user refers back to something discussed previously, rather than relying only on a short recent-context window?
A real conversation about Grandiosa exposed a retrieval failure and became a regression case for the end-to-end context pipeline. The investigation covers conversation persistence → memory extraction → promotion into Memory → historical retrieval → normal chat context assembly → autonomy context.
Evidence standard: a future pass is only considered demonstrated when the relevant historical source can be traced through retrieval/context assembly and the behaviour still works after the source has aged well beyond the recent conversation window. A plausible answer alone is not sufficient evidence.
Three ordinary runtime observations reproduced the same source-selection pattern. The same Open Loop remained dominant as it aged from 43 to 45 hours, while substantially fresher Conversation, Memory and Internal State context was simultaneously available.
| Observed | Dominant source | Age | Fresh conversation selected | Model outcome |
|---|---|---|---|---|
| 21:04 | same Open Loop | 43h | yes · 3 sources | skipped · unchanged |
| 22:06 | same Open Loop | 44h | yes · 3 sources at 0h | no_proposal |
| 23:09 | same Open Loop | 45h | yes · 3 sources at 1h | skipped · unchanged |
What this proves: the source-selection pattern is reproducible. What it does not prove: that the old Open Loop itself caused a no_proposal decision. The current hypothesis is a lifecycle/scope problem involving development-era Open Loops; causality remains to be established before tuning autonomy thresholds.
Commit f2755bca559af0cf2bc37fe2a79b1ced2df04a72 added sanitized source-selection and fingerprint observability. The protected deployment verified the disposable PostgreSQL migration cycle 0018 → 0019 → 0018 → 0019, the complete backend suite, dependency integrity, localhost-only API binding and Control Center availability.
The first deployment attempt also produced useful negative evidence: incorrect filesystem ownership caused the live migration to fail after the source fast-forward, and the automatic rollback could not read the same protected files. A retained protected backup and a scoped recovery procedure were then used to complete the deployment forward. The failure is documented because deployment behaviour is part of the system being tested, not something to hide from the research record.
Observations, hypotheses and demonstrated behaviour are deliberately kept separate. A single natural-looking response is an observation. Repetition under known conditions is stronger evidence. A traced provenance path plus a regression test is stronger again. Ada Research should not claim more than the available evidence supports.
Where the experiment goes next.
Grounded conversation provenance is now implemented: an autonomous proposal can retain the specific Conversation Core message that inspired it, and downstream policy can revalidate that source before delivery. Early live use has produced contextually relevant autonomous messages as well as repeated decisions to remain silent. The next task is still observation rather than threshold tuning: determine whether source selection, restraint and timing remain useful over time without repetition, stale development context, noise or excessive contact.
A focused lifecycle pass is also required for autonomy state. Pre-live iOS-test initiatives and old development Open Loops must not remain semantically dominant merely because they are unresolved, and an APNs-accepted delivery must be treated as completed for proposal lifecycle purposes without being misrepresented as proof that the user read, opened or answered it.
Communication continuity now includes collision handling: unsolicited autonomous delivery should not appear as a separate message while a text or phone conversation is actively underway. Explicit actions requested by the user inside that conversation must still be deliverable immediately.
Native phone-style calling has also passed its first physical end-to-end test. The next communication questions are no longer simply whether a call can be placed, but whether autonomous calling is chosen with good judgement and whether the intent and outcome of each communication attempt remain understandable later across text, voice and time.
Before broader integrations, operational resilience is also a priority. Ada now contains enough persistent state that automated backup, integrity verification and tested disaster recovery are becoming part of the system rather than optional server hygiene.
Calendar, geographic context, mail and Home Assistant are expected to come later. The intended architecture is that Home Assistant remains the deterministic sensor and actuator layer, while Ada receives carefully selected events and decides whether they are relevant enough to communicate.
A door left unlocked after the user genuinely leaves home is a useful example. Home Assistant can establish the factual state. Ada can decide whether a push is sufficient, whether the event deserves escalation, and — under an explicit future policy — whether an ignored critical message warrants a phone call.
The ambition is not unrestricted autonomy. The ambition is a system where increasingly rich context can be useful without becoming uncontrolled.
The model is replaceable. The continuity should not be.
Ada is still built from language models, databases, APIs and deterministic software. The research question is not whether that fact can be hidden. It is how far a persistent identity can develop when memory, communication, context and action are engineered as one coherent system — while keeping every important boundary explicit.
Interested in the experiment?
Ada is an ongoing independent research and development project by Varion. Technical discussion, criticism and thoughtful questions are welcome.