Living documentation · decision history
Every architecture decision, from the first to the last, told in a few sentences and linked to the building blocks it shaped.
Version 4.6.0November 10, 2026kept current at every commit, from the repository's data
Overview
Each bar stacks a month's decisions, colored by theme. Click a bar to jump there.
Timeline
Each decision in a few sentences, with the building blocks it shaped. Filter by theme, search for a word, or follow a building block.
Chapter 1 · Oct 1, 2025 – Dec 31, 2025 · 48 decisions
The agent graph, sessions kept on the server side, the planner, the data registry, memory, observability, the six languages and deployment on a Raspberry Pi: the framework everything else rests on.
LIA needs an engine that can carry a conversation through several steps, stop to ask for approval, then pick up again. LangGraph provides this execution graph: each conversation's state is saved in the database and answers arrive word by word.
Tokens stored in the browser were exposed to theft and impossible to revoke. An intermediate server (BFF) now keeps the session on the server side and hands the browser nothing but a cookie JavaScript can't read — a session can be revoked instantly.
Sending the whole tool catalogue to the model with every question made the prompt, and the cost, ten times bigger. The router detects which domains are involved and only their subset of tools is loaded, falling back to the full catalogue when in doubt.
Rather than interrupting execution tool by tool, LIA presented her plan for approval before starting. Today plan approval is automatic: approval happens on each sensitive action.
The first plans were too simplistic and often failed. The planner now analyzes the intent, breaks the request down, then writes an execution plan justified step by step.
The parallel executor launched the main plan and its fallback alternative at the same time: two calls, twice the cost. Discarded steps are now removed before each wave is launched.
Asking for “all contacts” could bring back hundreds of entries and blow up the cost. Three barriers — a planner warning, a hard cap in the tool, logging — now prevent an unbounded list.
Some graph nodes ran to hundreds of lines and had become unreadable. The business logic moves into dedicated services; a node just coordinates.
A configuration file of nearly 1,800 lines held every setting. It is broken up into modules per domain, combined into a single settings object validated at startup, without changing how it is imported.
The domain was called Gmail, as if there were only one provider. It gets a generic name so Outlook, Apple Mail and others can join without renaming everything each time one is added.
Do internal tools (context, memory) need a fake “connector”? No: tools that talk to an external service and utility tools remain two distinct categories, each with its own simple pattern.
Tools returned raw text that nothing kept. A data registry now keeps every item returned, with its metadata, so a follow-up question can refer to it and a draft can be confirmed.
The assistant forgot everything from one session to the next. A long-term memory, isolated per person and searched by meaning, keeps preferences and important facts — including sensitive topics to be handled with tact.
Running tools one after another added up the delays. An execution plan expresses dependencies, conditions and fallbacks, and launches everything it can at the same time.
Every connector tool repeated the same 150 lines (authentication, errors, cache). A base class factors out that groundwork; a new tool now only writes what is specific to it.
Each domain identifies and displays its items differently. A context type registry describes each domain once, and resolving “this one” or “the third one” works the same way everywhere.
Users had to be protected from abuse and external API quotas preserved, even across several instances. Distributed rate limiting through Redis, per person and per category, falls back to local limiting if Redis goes down.
Waiting ten seconds for a complete answer is painful. The server streams every word, the plan's steps and the approval requests as they happen, through Server-Sent Events.
The planner needs to know which tools exist, what they cost and what they require. Typed manifests serve as both documentation and configuration, filtered by domain to save tokens.
No single tool covers metrics, traces and the tracking of model calls. Prometheus, Tempo and Langfuse each do their own job, and the application keeps running if one of them goes down.
Google access had to stay unreadable in the database, renew before it expired and never be refreshed twice at the same time. Encryption at rest, early refresh under a distributed lock and PKCE cover its lifecycle.
To resume after an interruption or a restart, the graph's state is saved in PostgreSQL per conversation thread, with merge rules that trim the history to the token budget.
Each part handled its errors its own way. A common format for tools, a hierarchy of logged exceptions and messages translated into six languages make errors consistent and measurable.
The interface, the server's messages and the URLs must speak the person's language. i18next in the browser, gettext on the server, six languages and localized URLs for search engines.
The instructions given to models must be able to evolve and to roll back. They live in versioned files, loaded according to a configurable version and filled in with variables.
Routing, planning and answering don't have the same needs. Each component gets its own model, behind an abstraction that lets you switch providers without touching the code.
To be of any use, logs must be machine-readable. structlog produces JSON with its context (request, person, conversation) and filters out personal data before writing.
UUID identifiers, dates always in UTC, soft deletion and JSONB metadata: the PostgreSQL schema conventions are set once for the whole application.
Sessions, OAuth states, rate limiting, locks and caches all go through Redis. Each use has its own database, expirations and atomic operations, and an outage degrades the service without blocking it.
A conversation is full of implicit references: “the second one”, “this one”, “them”. Context resolution detects the kind of turn and links these words to the right items, without mixing up domains, in six languages.
You can't call real models in every test. The strategy mocks the provider at its boundary, isolates each test's database and covers asynchronous code.
The REST API follows a single convention: a version prefix, validated Pydantic schemas, routers per domain and a common error format, all documented automatically.
Around fifteen services must run in development just as on a Raspberry Pi 5. Docker Compose orchestrates it all, with health checks, resource limits and images for two architectures.
An external service failing must not bring the whole application down with it. Circuit breakers, retries with backoff, health probes and controlled degradation keep the service running.
Enthusiastic, professor or friend: everyone picks LIA's tone. Personalities are stored in the database, translated into six languages and injected into the prompts.
To truly personalize, LIA extracts what matters from conversations in the background, finds it again by meaning and adjusts her tone to how sensitive the topic is, without ever holding up the answer.
Server-side rendering, answers streamed live, six languages and cookie authentication: the interface is built on the Next.js App Router.
Every schema change goes through a named, dated and reversible Alembic migration that detects all the models automatically.
Saved conversations must stay readable when their format changes. The state carries a version number and is migrated automatically on load.
A conversation is born with the first message, can be soft-deleted, leaves an audit log and disappears in a cascade with the account, in line with GDPR.
Each domain (email, contacts, calendar…) has its own agent and tools, supervised by a parent graph that shares a single state and propagates observability.
Sending an email or creating an appointment requires approval. The draft is shown, can be edited or canceled, and is only carried out after confirmation — every decision is recorded.
Repositories, services and routers chain together through FastAPI dependency injection, with database sessions opened and closed at the right time and easy to mock in tests. A route failure reaches the session to roll back its transaction; closing finishes before cancellation propagates.
Gmail, Calendar, Contacts, Drive and Tasks share a common base: centralized OAuth scopes, tokens renewed under a lock and quotas respected service by service.
Every model call must be counted and optimized. Precise per-provider token counting, real-time cost, caching and semantic tool selection have shrunk the catalogue sent tenfold.
Exchange rates, memory cleanup, sending reminders: some jobs must run on their own. An asynchronous scheduler launches them on cron expressions, shuts down cleanly and publishes its metrics.
Keyword lists per language gave weak scores and needed endless upkeep. The router now compares the meaning of the question with that of the domains and tools, in more than a hundred languages.
A reminder is created in natural language, stored in UTC and goes out as a push notification to every device, with a personalized message — never sent twice, even with several workers.
Chapter 2 · Jan 1, 2026 – Mar 31, 2026 · 18 decisions
A first round of security hardening, voice dictation, knowledge spaces and syncing an online folder, LIA's journals, browser control, usage limits — and the first public open-source release.
HTTP-only cookies, parameterized queries, CSRF protection, hashed passwords: the application aligns its defenses with OWASP recommendations.
Agent results can be contacts, emails, places… Explicit validation of this union of types prevents any silent data loss during conversion.
After each answer, LIA spots one or two topics the person cares about in the background, without slowing the conversation down, to personalize her answers and then her initiatives.
The “OK Guy” wake word, a mic button, end-of-speech detection and free multilingual transcription on the server: voice input arrives with no recurring API cost.
Anyone can upload their documents; LIA splits them into chunks, indexes them and retrieves them through hybrid search (meaning + words) to enrich her answers, in strictly isolated spaces.
Instead of downloading your files and then uploading them, you link a Drive folder: LIA reuses the existing connector and indexes the documents with the same pipeline, file by file.
The assistant writes down her own reflections and observations, in the first person, colored by her personality, and reads them back by meaning to reason better with each person.
Asked “What can you do?”, LIA gave a generic answer. A system knowledge space, indexed from the FAQ, gives her exact answers about her own features.
Filling in a form, looking for a product, reading a dynamic page: an autonomous agent drives an isolated Playwright browser and carries out a task described in natural language.
Every model call costs real money. Per-person caps — tokens, messages, cost — per period or in total protect the operator from runaway spending.
A disabled MCP app kept receiving requests. The domains returned by the analyzer are now filtered against the ones actually available, at every step.
A fixed plan couldn't react to what it discovered. An initiative phase rereads the results and suggests useful checks, and an iterative sub-agent can explore a complex MCP server.
With four processes, a changed setting reached only one of them. An invalidation broadcast over Redis Pub/Sub reloads the cache in every worker.
The conversational personality was contaminating the journal notes. A fixed analyst persona now writes clinical observations and actionable directives, whatever personality is active.
The per-domain agent nodes were never traversed anymore. The analysis documents it, so the admin panel stops offering settings that do nothing.
To stop paying for, and waiting on, an external service at every semantic search, a multilingual embedding model runs on the machine itself, Raspberry Pi included.
Two different stores meant five embedding computations per turn. Memory and journals move to PostgreSQL with pgvector, and a single embedding serves every use.
Active, deactivated, deleted, erased: an account follows a lifecycle that keeps the billing history after deletion and erases everything on request under GDPR.
Chapter 3 · Apr 1, 2026 – Jun 30, 2026 · 23 decisions
ReAct mode, an evolving psyche, skills, health data, the morning briefing, LIA's voice, sub-agents and reasoning tuned per provider.
The personality was a fixed text. A five-layer psychological engine — traits, mood, emotions, relationship, motivations — makes LIA's state evolve as the exchanges go on.
Semantic search moves to Gemini, with two separate spaces for storing and for searching, and two vectors per item (content and keywords) for better retrieval.
A rigid plan can't adapt to an unexpected result. A second mode, which the person can choose, lets the model call a tool, read the result and decide what comes next, in a loop built into the graph.
Two competing mechanisms identified skills. The query analyzer now compares the request with the description of each active skill: a single, semantic signal.
The context manager kept three views per domain, one of them useless. It now keeps only the last list and the current item, which simplifies reference resolution.
Weather alerts talked about home even while traveling. A last known location, kept on request, lets notifications follow the person wherever they are.
Several output fields were getting mixed up. Business entities go through a single explicit, flat contract that consumers read without guessing.
A map, a dashboard, a QR code: besides text, a skill can return an interactive frame or an image, through a typed JSON contract.
An iPhone shortcut sends steps and heart rate in batches every day, authenticated by a revocable personal token, to follow trends and spot changes.
The home page becomes a daily briefing: weather, agenda, emails, reminders… read in parallel outside the agent graph, with a cache per section and a written summary.
Model capabilities and prices were hard-coded. The catalogue now lives in the database, and the administrator can edit it without redeploying.
The journal becomes LIA's organ of metacognition: raw observations, directives, syntheses and a portrait of the person, each with its evidence status and its self-assessment.
Neural, multilingual speech synthesis, streamed sentence by sentence, gives LIA a voice, with the first sound in under three seconds and everyone free to switch it on.
As an option, speech recognition can go through ElevenLabs Scribe, which is more accurate; prices gain a per-minute or per-hour-of-audio unit so they are counted correctly.
Fourteen environment variables controlled speech synthesis. It becomes a role in the catalogue, chosen in the admin panel like any other model.
A persistent HTTP client, sentence splitting during generation and immediate sending: the voice starts speaking before the written answer is finished.
A summary of five emails had consumed nearly 500,000 tokens. Delegating to a sub-agent goes through a configurable, bounded ReAct loop, and the old mechanism is removed.
“My medical appointments” returned nothing: the word “medical” was searched for as is. A planning principle separates what a service can filter from what the model has to judge.
After confirmation, three deleted reminders showed up as three identical lines. A declarative registry per draft type, checked at startup, sets how each one is displayed.
A conversation that grew too long blocked any new message. Compaction gains timeouts, retries, observability, and a visible truncation instead of a hard stop.
A homemade client of 1,800 lines is replaced by the native client; how reasoning is requested becomes a per-provider configuration.
The journal produced useless entries. It writes less, keeps its discovery mechanisms, and each level serves a specific purpose when it is read.
Each process exposed its own counters. Prometheus's multiprocess mode aggregates them, and each gauge declares how it should be combined.
Chapter 4 · Jul 1, 2026 – Jul 31, 2026 · 101 decisions
A month of a hundred decisions: an end-to-end audit, security and backups, a CI that runs exactly what the developer runs, alerts that wake you up for a reason, and the first honesty rules.
The links between data types and tools came from two sources that had drifted apart. They are now the union of the ontology and the manifests, and tests guarantee their integrity.
The answer waited for the initiative to finish before loading its context. The two now overlap, which shaves several seconds off turns that use tools.
Resuming after an approval replayed costly calls. Each node now raises only one interrupt and loops back through the graph, which makes resuming safe.
The client's address could be spoofed and HTML injected. Ports bound to the loopback interface, verified proxy headers and HTML sanitization close both holes.
Three windowing functions were no longer called anywhere. They go, along with their settings and their tests: a dead subsystem costs something at every change.
An audit found seven families of subtle defects. Each one is fixed and gets a permanent guard — a test, a metric or a written rule — so it never comes back.
An audit targeted three boundaries: synchronous code that froze the async loop, internal services reachable from the local network, and model output displayed unfiltered. Each defect is fixed and measured before and after.
Some defects only show up in parallel runs or when an account is deleted. One database session per parallel task, a complete GDPR purge and a hardened skills sandbox eliminate them.
The Content Security Policy broke MCP widgets. Each third-party widget now gets its own document, and therefore its own policy, without weakening the application's.
An nginx reverse proxy shipped with the very first version had never been connected to anything. It is removed, because a file that serves no purpose misleads whoever reads it.
A model sometimes answered with JSON inside its text instead of the expected structure, and the request failed. A safety net recovers that JSON, and a prompt-writing convention avoids the conflict.
“My next medical appointments” failed at random depending on the mode. The tool lists the period, then does the filtering itself, resets the dates and caps the volume read.
Each domain has a singular name and a plural result key, both drawn from a single registry: no more hand-maintained tables.
Parts of the human approval flow stayed in French for everyone. Instructions to the models switch to neutral English, and everything the person reads is translated into LIA's six languages, backed by a parity guard.
LIA's mood stayed stuck in a few states. The cause — emotions created on every turn — is treated at the source, with thresholds you can tune without a rebuild.
The psychological state was described with abstract adjectives and couldn't be felt. It now comes through in the way she talks — pace, length, register — without ever saying “I feel”.
Pipeline and ReAct modes triggered confirmations in two different ways. A single, typed contract now serves every approval, whatever the mode.
Autonomy engines and an approval framework were no longer called. They are removed in five verified batches, without losing anything still alive.
Brave, OpenWeatherMap and Perplexity rate-limited process by process, which was wrong with multiple workers. They inherit a hardened base with a deterministic lifecycle.
No database backup was versioned. A dedicated container exports every night with retention, and a script proves the restore works in a throwaway database.
The backup encryption options are analyzed and compared; the decision is to defer, with a path mapped out toward an off-site copy.
Each worker shared a single connection to save every conversation. Connection pools remove this bottleneck, the system's biggest.
Installed versions drifted from one machine to the next. Universal lockfiles, generated by uv and checked in CI, pin every transitive dependency.
250 integration tests ran in no job at all. They join CI with a real database, quarantines are banned and coverage can no longer go down.
The client layer raised raw HTTP exceptions. It now raises domain errors, with exactly the same response for the caller.
The health probe could never report a failure. It is split into “alive” (always 200) and “ready” (503 until the database and Redis respond).
The heart of the chat was protected by type checking alone. Hundreds of tests now cover streaming, approvals and voice, with coverage thresholds that never go backwards.
Closing the tab interrupted generation. The answer is now produced separately, streamed through Redis Streams, and picks up live again when you come back.
The skill generator required four manual steps. The skill now installs directly, through a single, hardened import pipeline.
Alerting had been switched off without a written decision. A minimal core of vital alerts is back, evaluated by Prometheus and sent by email, each with its own runbook.
A route to “my brother” sometimes headed off to an arbitrary place. Deterministic evidence of a reference to a person and a runtime parameter guard close every link in the failure chain.
Only 14% of parameters carried a semantic type. An annotation campaign finally links participants, senders, addresses and dates from one tool to another.
The function that streams every answer was over 1,100 lines long. Voice coordination is extracted from it into a typed state machine.
The API's startup ran to 780 lines. Each subsystem gets its own initialization module, and a single function decides the order.
Routers and services now raise centralized errors, with an identical response for clients: the rule now applies to the whole backend.
Rendering confirmation previews was a cascade of conditions. A rendering table per draft type replaces it.
The most heavily used domain depended on too many others. Authentication and accounts are separated so identity remains a stable foundation.
LIA can call a third party to check availability, then report a summary back in the chat. The call goes through your own connector and stays confirmed, bounded and read-only.
Analyzing a plan's failures stays advisory: it feeds observability, without launching a new plan on its own.
A restart left documents stuck mid-processing. Documents and sources become leased jobs, picked up again automatically.
Eleven audit findings are dealt with, without delegation and without regression: every refactoring starts with tests that pin down the current behavior.
Half of the notifications were about the same subject. Interests are grouped by perceived subject and drawn according to their rarity, backed by measurements.
Approval requests were just text to interpret. They become cards with buttons, after latent defects were fixed.
A revoked connector produced a vague apology. A banner offers one-click reconnection, thanks to classification by exception type, never by message.
The heartbeat kept coming back to the same interests with nothing concrete. A varied sample, a shared ledger, content-level anti-repetition and concrete enrichment put it back on track.
On iPhone, maps and MCP apps stayed blank without a message. A suitable isolation posture and visible failure states fix the display.
Widgets showed up twice or got lost. The model never writes their markup anymore: the host places them, and they travel with their message.
The execution steps vanished at the answer's first word. They are now kept with the message and can be looked at afterwards.
👍 or 👎 under every answer, with an optional comment: the verdict is kept and fed back into learning, never used to regenerate the answer on your behalf.
“I need to call the plumber back” died with the conversation. A commitments ledger keeps them, and the heartbeat follows up with restraint.
“Do this for me every morning” now gets done right in the chat, after confirmation, and LIA suggests a routine when she sees a request coming back.
Document spaces become a domain the planner queries, and a 360° view brings together everything LIA knows about a person.
The psychological settings had shipped without any measurement. An observation instrument comes first, and the intended properties become tests.
Passkeys, a TOTP second factor with backup codes and a fresh check before any sensitive action: maximum security and maximum comfort, without ever exposing a secret to the browser.
Everyone sees the devices connected to their account and can revoke one remotely, with a strict minimum of data (browser families, truncated IP).
Under GDPR data portability, everyone can download all of their data, prepared by durable jobs, without a single secret ever being exported.
A single service worker handles notifications and offline use, with a no-network page in LIA's colors.
When a turn produces no data, the answer draws on recent entities, without ever letting old data contaminate a different question.
The heartbeat transferred 30,000 rows per pass for a handful of figures. A daily aggregation in the database returns one row per day.
Isolating a script by switching users only protected anything if the API ran as root. Every skill script now runs in a throwaway container, with no network.
Reindexing a space left it partly empty. Two generations coexist, and a pointer only switches over once the new one is ready.
The continuous integration workflow held nearly a hundred commands written inline. Each step now calls a Taskfile task: CI literally runs what everyone runs locally.
Frontend hooks that nothing used are removed, and the build proves it: less code to maintain, no feature lost.
Classifying a free-form reply to an approval request (yes, no, edit) went wrong on some tool names. Classification now goes by action verb, with examples that cover every case.
The voice cut off in the middle of a URL or a decimal number. A delimiter only ends a sentence when a space follows it or the text ends there, and the two implementations are merged into one.
Ten test suites turned themselves off for lack of an API key, so they never ran in CI. The provider is mocked or the test is visibly marked, and a guard prevents any relapse.
Nine modules and their orphaned translations are deleted, key by key, without touching the ones a live component still shares.
A vulnerability in a JavaScript dependency called for an incompatible version. A small interop patch applies the real upstream fix without breaking the tooling.
Key parity couldn't see that a translation was truncated. The truncations are repaired, and a ratchet keeps them from increasing.
A single journal theme was getting almost every entry. Entries are now classified by subject, and a measurement harness checks that every theme stays alive.
Six image requests in a row had failed: the model was writing the word “null” as the skill name. Outputs are normalized, and two caps that made the feature impossible are lifted.
On mobile, an answer could stay stuck on “Generating…” even though it was ready. A browser-side watchdog detects the silence and resumes the stream automatically.
Four workers were reindexing the system knowledge at the same time and overwhelming the provider. Only one claims the right to index, and its cache survives a deployment.
On first startup, every worker recomputed the same embeddings. A file-based claim designates a single worker to compute them; the others wait for its result.
Every decision to extract something into memory, interests or the journal is now counted, to check that no kind of turn is skipped by mistake.
To adjust a skill, the assistant rereads the current version and regenerates the whole package, confirmed within the tool, rather than applying a partial patch.
Every topic mentioned used to become an interest. The question is now: has the person shown a lasting attachment? Asking isn't liking, and each new entry must cite its grounds.
Text written by a third party — an email, an invitation, a page — must stay data, never an instruction. Trust is declared per data type and enforced wherever the model reads it.
A hybrid memory search had gone unused for months. The module, its settings and its metrics are gone, with proof of inactivity to back it up.
The ReAct turn's instructions were added as messages and disappeared when the history was windowed. They become state, rebuilt at the top on every iteration.
Time spent waiting for your approval was counted as compute. The ReAct budget now counts only real computation, and a guard stops a loop that keeps repeating the same call.
A global CSS rule had disabled every “sticky” element from the very start. A different overflow value clips the page without breaking the stickiness.
Finding a setting whose name you knew meant unfolding everything. A search field indexes the sections and says clearly when a destination doesn't exist.
The 2026-07-28 revision of the MCP protocol is an overhaul. LIA speaks both eras and binds its OAuth to the discovered issuer, with no regression.
A link that prefills the input and a link that sends the request now use two distinct parameters, so a text the person hasn't approved is never sent.
After a call, only a summary and a few data points survived. Commitments, suggested follow-ups and uncertainties are now kept in a structured debrief.
A routine can fire on a condition — an overdue task, a change in the weather — checked on every tick, and it runs only once per new fact.
LIA gathers what she already knows about people — commitments, calls, memories — into a read-only relationship view, with no new table.
Callouts, bullets, tables, collapsible blocks: a vocabulary of components makes laid-out answers possible, sanitized against an extended schema.
Beyond the technical side, a dashboard measures useful results, activation, retention and cost per result, from durable data in the database.
A phone call report came back in English and without its debrief: one path was going around the shared door. All structured output now goes through it, backed by an AST guard.
Finding each other by exact name, connecting after mutual consent, writing from assistant to assistant and sharing read-only: a dedicated context organizes these links.
The public area adopts a cosmic identity and scroll-driven choreographies, applied through a CSS scope without rewriting the components.
“Is he available tomorrow?” got the answer that no service was configured. Routing now knows about connections, and a failure is reported as it is.
The same request would fail, then succeed, at random. A filtered catalogue must be closed: everything a tool requires must be produced by another tool in the catalogue.
The planner couldn't see the limits the tool was silently enforcing. Every enforced constraint is published to whoever produces the value, and a validation verdict doesn't amount to a failure.
A number on screen must be exact or not exist: counting from a truncated page silently under-reports. An aggregate over the whole set, pagination for the rows alone, the exact total beside them.
The content of a relayed message was erased as soon as it was delivered. It is now kept for a bounded time, like calls, before being purged.
Searching for a peer by name or by address goes through one field, and it's the server that decides which one it is.
The relationships view can read contacts and birthdays from the provider, as long as it says what it looked at and checks every match.
Agreeing to be discovered doesn't mean showing your email address: that's a second consent, off by default.
Chapter 5 · Aug 1, 2026 – Aug 31, 2026 · 62 decisions
Accessibility by contract, settings and capabilities on display, time-of-day pricing, the self-hosting installer, a model catalogue that tells the truth, the expressive eyes and self-diagnostics.
A tool that was announced but missing from the registry answered with nothing. A guard compares the two, and the contact card shows all its fields.
A 360° overview came back with parts missing: the tool couldn't be reached from the requested domain. Every tool declares the domains it serves, and a click is not a sentence.
A second 360° overview stayed frozen on the first one: the browser's router was reusing the URL. A deep link from the chat becomes a full navigation.
A domain that can only write pushes towards writing. Three read capabilities (calls, commitments, messages) are added, and a person's identity can be corrected.
A wrong reference path between steps was only discovered at run time. A CI guard checks that every published example is actually produced.
The clarification displayed the technical description of a problem. Each kind of problem has its own question, in six languages, checked at startup.
The 👍/👎 on a proactive notification sometimes targeted the wrong row. The identifier is chosen by the producer before sending and is used everywhere.
To stop receiving notifications drawn from your emails, you had to disconnect your email. Eleven switches now separate the connection from the permission to interrupt.
Computing the next five runs brought a daylight-saving defect to light. A routine runs at most once per local day, by construction.
The empty chat offers starters drawn from the already-cached briefing, never from a fresh fetch: a suggestion only exists if the evidence does.
The proactivity panels set frequency and sources without showing the notifications they produced. These are now visible there, collapsed.
A memory stated a preference without saying where it came from. Every conclusion keeps a reference to its origin, and a deletion leaves a dated trace.
Relayed messages, notifications, reminders: five streams had nowhere to be read. An “Alerts” destination gathers them, with nothing to configure there.
A call's follow-ups sent the message immediately. They now prefill the input, so that nothing is accepted without you.
An interest's weight is explained through its components, never by a score: you see the reasoning, not a misleading grade.
Three components hard-coded their own status colors. A status now names a tone, rendered by a single component that inherits the contrast guard.
A UX audit showed that accessibility was only checked on a fraction of the interface. A field's contract lives in one place, and an empty screen always offers a way out.
Actions of the same kind took different shapes from one screen to the next. Four action altitudes, four button shapes, and nothing else.
Three similar screens exposed their actions in three different ways, some of them invisible from the keyboard. A single component now keeps them always visible and accessible.
The debug panel showed the steps out of order. Every call now carries the instant it happened, measured from the start of the run, and the panel follows the real execution order.
Going back to a page re-ran a card action that had already been done. Every click gets a single-use identifier, checked at the moment it is consumed.
Deployment used to wipe the live directory out from under the running containers. The new version is prepared on the side and switches over only once it is ready.
Promoting varied fields to Loki labels multiplied the indexed streams. Only fields with a small, closed set of values become labels; the rest is filtered at read time.
Three places read the caller's address, and a visitor could forge it. A single resolver prefers the header that Cloudflare overwrites, which closes the loophole around the limits.
LIA learns when you do what through deterministic, explainable statistics, calibrated by simulation. Every habit can be seen, corrected and blocked, and a single switch shuts off all learning.
A guided installer builds the application locally or uses digest-verified images, and never reads a secret from anywhere but standard input.
Per-user limits don't bound an instance: N accounts make for unbounded spending. A daily instance budget, updated atomically, bounds the deployment itself.
Transcription, speech synthesis, images… every capability that isn't a connector has its own admin switch, which truly takes the capability away from the assistant.
The demonstrator's tests froze what the code did on the day it shipped. Every promise is recomputed from the source of truth; an unclassified new feature makes CI fail.
The last known position only served notifications. Every feature now reads it, and its age is always stated.
Some providers only return usage if you ask for it. Every provider declares how it is counted, checked at startup, and a paid call with no count triggers an alert.
The per-model timeout was editable but never enforced. It becomes the transport bound of every call, tested against real latencies, and nothing around a call cuts it shorter.
1,200 lines of resumption strategy had never been called. They are deleted: dead code has a cost on every change.
DeepSeek bills according to the time of day in UTC. Every price row carries its time windows, and every call is priced at the moment it was made.
LIA installs portable plugins built to the Agent Plugins standard: skills and MCP servers in one go, with a component-by-component report.
“Do some research, then format it as a CSV”: a writer model produces the structured content, and local engines build the Excel, Word, PowerPoint or PDF file.
Fifty-one sections folded into an accordion was a lot. A rail lists the sections and a panel shows the selected one, both rendered from a single table.
The capabilities page described the product as it was six months earlier. A single aggregation answers “where does this capability stand?”, and an assert forces every new feature to appear there.
Administering 124 models one dialog at a time isn't sustainable. The catalogue exports to an Excel workbook and imports back, with a preview of the changes before anything is written.
“See the full history” led to a page that didn't have it. A public, server-rendered page publishes every version.
The journal's self-evaluation hadn't produced a single signal in months. Per-person adaptive thresholds, an initiative guard and loops that are finally closed bring it back to life.
Reasoning functions over the ontology were consumed by nothing. They are removed, as the doctrine says: an unwired capability disappears.
An activity timeline gathers what LIA did on her own initiative, read in parallel from the existing audit logs.
When a fact changes, the old memory is no longer erased: it is marked as replaced and linked to its successor.
LIA remembers explicit instructions about the way she works for you — a seventh memory category, with strict criteria.
LIA's emotional state modulates the parameters of the synthetic voice — expressiveness, stability — with gentle gains and a neutral zone.
LIA's proposals appear in a dedicated inbox, with no new authority whatsoever, and the ReAct budget adapts to the work actually produced.
The evolution program closes on a proven inventory: ambient proactivity already existed in the form of conditional routines, whose creation counts as consent. Multi-day missions, an automatic critic and turning routines into skills are left to the owner's decision, backed by evidence.
Animated eyes show what LIA is doing — thinking, searching, speaking, waiting for your approval — from signals that already existed, with no new backend at all.
Three Python versions coexisted across images, CI and workstations. One interpreter, CPython 3.14 on Debian Trixie, for the whole environment.
The lexical score was crushing the semantic score and rejecting good passages. The threshold applies to meaning first, and the lexical side only adds a bounded bonus.
Absolute black for OLED screens: a refinement of dark mode carried by an attribute, not a fourth theme that would break the others.
89 of 114 models carried default capabilities that had never been verified. Two public registries feed the catalogue, and every row says where its capabilities come from.
The mobile apps are published once, for every self-hosted server. Android receives notifications through each server's own Firebase; iOS goes through a relay that carries no content.
Asking a model to think went through four stored shapes and seven builders. One intent, a derived profile and a single translation seam per provider.
LIA produced hundreds of metrics without reading a single one. A periodic self-check, a memory of diagnosed incidents, and answers that work around a known outage.
“Give me a minute” is not an answer. The ReAct loop shares the pipeline's memory, earns its budget by producing, and never publishes a message announcing work it won't do.
A turn's identity traveled in an untyped dictionary. It moves into a typed, frozen LangGraph context — without adopting Agent Server, which is incompatible with LIA.
For calculations a model gets wrong, the agent writes a short script and runs it in the existing sandbox, in ReAct mode only, with the data passed in rather than retyped.
Deployment used to end on an error everyone had learned to ignore. The remote verdict is now read from a file, never inferred from an SSH exit code.
53 settings sections had the same color and sometimes the same icon. The colliding icons are fixed, and twelve measured group tones help you find your way.
The eyes had hit the ceiling of CSS. A TypeScript engine computes every channel on every frame and publishes properties that the stylesheet merely reads.
Chapter 6 · Sep 1, 2026 – today · 135 decisions
Sealed registers, exact counts, the Workboard, meetings, the phone and Live mode — and failures spelled out rather than guessed.
The model writing the answer declares its register itself — reassured, sorry, cheerful… — in a vocabulary of its own, made for animating the face.
Six background jobs were starting in the same second. Random jitter at the source, a short shock absorber on the provider side and a wait that fails open absorb the burst.
Reading the JSON schemas of MCP tools was duplicated. A single module reads the declaration to the letter of the standard, for the adapter and the planner alike.
The ReAct budget only counted reasoning. Tool time becomes a second, named budget, every call has its own bound, and a delegation can no longer use everything up.
A literature review served as a lens: provenance survives compaction, the turn's anchor holds, trace counts are honest, validation checks coverage and the delivered context is measured.
The “+” button turns your phone or computer into a recorder: the audio goes out in segments, and LIA returns structured minutes — date, participants, decisions, action items.
Thirty built-in templates or your own, chosen automatically to fit the meeting, and minutes that can be reformatted into another template.
Resetting a conversation also erased some of what LIA had learned. Every key family declares its scope, and the purge removes only what its family declares.
A push notification from Gmail or Drive puts a wake-up in the queue. LIA serves it under all her eligibility rules, and Drive only resyncs what has changed.
A knowledge space follows a Gmail label, never the whole mailbox. Removing the label removes the document: the label is the consent.
Every tool declares whether it reads, drafts, asks for confirmation or acts. Every action is recorded before it happens, then settled from its result, and three registers, which the instance can seal per account, trace what LIA did, read and decided.
The brows have an arch, one shared breath carries the face, and the mouth has a life of its own: LIA's face moves without ever leaving a budget of a few pixels.
A weekly grid shows when each routine ran and with what result, from a history written at the moment of the result.
The diagnostician collects its evidence at the moment the incident happens, source by source, and a text sent to an embeddings provider is always an exact string.
Ollama is served by its native client, and its server itself declares what its models can do: tools, vision, reasoning, context size.
A single recurrence engine serves routines and reminders: “every other Tuesday at 8 am” becomes possible, and a reminder can finally repeat.
For each relationship, LIA writes a dated summary once a day — where you stand, what to bring up — which the chat reads without ever passing it off as a verified fact.
Every module that calls a model declares where its spending is recorded, and every register row declares who its author is: you, a routine, or LIA on her own.
The dashboard read your sources twice per load. Simultaneous requests now share the same work, even across several processes.
Every call the platform pays for is bounded both by the account's ceiling and by the instance's daily budget, at the innermost door.
Downloaded registers had a row cap. A server-side cursor streams them in full, with an exact total announced up front.
The model says what a piece of content is — list, quote, callout, table — and the renderer draws it with the native mechanisms of Word, PowerPoint, Excel and PDF, without ever overflowing.
A structured answer truncated by the token limit is no longer stitched back into a shorter document announced as a success: it is a refusal, reported as such.
A ticket has a lifecycle, a holder and a result. LIA can run a ticket, ask her questions on it and wait for your answer, alone or with a peer.
You pin your favorite settings sections in a floating dock: the list follows your account, the position follows your device.
Context size is no longer an instance-wide setting: every configured slot has its own, prefilled from what the server declares.
Images, documents and screenshots produced by LIA get their own gallery, and resetting a conversation no longer erases the files of other conversations.
Twenty-five capabilities each have their own switch. Turning a capability off removes the feature, never your data, and the capability map only counts what it names.
A meeting ends at 3 pm: LIA can ask how it went right afterwards, and a watch on an expected email is served to the minute.
A kept answer is a copy that belongs to you: it survives resetting the conversation, and it can be reread and exported.
Every process declares and publishes the memory it occupies: the supervisor no longer loads the application, heavy libraries load when they are used, and the voice cache is bounded.
The prompt audit found six places where the text said something other than the code. Every variable has a producer, every bound comes from a single constant.
A model that thinks by default spent its whole budget thinking and returned empty reminders. A short answer is requested without reasoning, and a model family is declared once.
A tool result is projected item by item under a token budget, and the cut is stated: the agent reads whole emails instead of technical headers.
An email arrives cleaned up — no quoted history, no signature — at three levels of detail, and its summary is computed only once, then cached.
Two independent emails in the same turn are presented one after the other, each with its own decision; only a batch that has already been approved stays grouped.
A draft card is described only once and drawn to suit the surface: a visual card in the chat, readable text on a ticket.
LIA calls you on a number verified by a spoken code, reads your data during the call, and what you say becomes your own message in the chat.
Every kept answer is indexed in a personal knowledge space: LIA can find it again when you bring it up with her.
Your portrait draws on four sources — memories, interests, habits, relationships — and says which ones it was able to read.
Instead of a catalogue cut off in registration order, the ReAct loop binds the tools most relevant to your question, while covering every family.
Brows sitting on the eye, speech generated syllable by syllable, varied gestures and little scenes at rest: the avatar never plays the same thing twice.
A document from a knowledge space, even a paused one, can be attached to a message as a copy, without touching the space.
LIA opens an attachment: its text when it has one, the vision model when it's an image or a scan.
A linked Drive folder is indexed together with its subfolders, and past a threshold LIA states the exact number of files before syncing.
A script can call a service through a single proxy, with tokens it cannot read. An unknown host leads to a question LIA cannot skip.
A voice model listens and answers in the same breath, on your own key; every request for data or action is delegated to LIA's engine, under the same rules as the chat.
Every provider declares how it connects and how it delegates, without any branching on its name: Gemini Live, GPT-Live and then ElevenLabs go through the same seam.
On the phone as in the browser, “Live” delegates every request during the conversation, and “Live direct” reads without acting, then relays your words at the end: one wrap-up for both.
Reconnecting your Google or Microsoft services takes a single OAuth flow per account, verified by a signed identity, and each service keeps its own state.
When a tool fails, LIA says so with the real reason instead of inventing a diagnosis, and the metrics finally count failures as failures.
A database connection never waits for a provider's answer any more: stuck wake-ups, held locks and idle “in transaction” connections disappear.
Every image model family declares what it accepts and how it is billed: OpenAI and Qwen Image are each served by a single client, and an image can be edited.
The request surface of Claude models is declared once, and the prompt cache is shaped and billed exactly the way the provider measures it.
Wikipedia, browsing, Places, weather and environment ask nothing of the person: the administrator turns them on for everyone.
An option makes every ReAct turn reuse the previous turn's prefix — all the tools, then the turn's context after the question — so that tokens already sent cost less.
Stable before variable, a single boundary, no cache write that goes unread: every provider translates the same rule into its own mechanism.
What the loop sets out to get ends up obtained or declared missing. A declared gap opens a bounded recovery pass, and the answer says what could not be obtained.
Everyone chooses between frequent and occasional exchanges. Frequent: LIA keeps every tool and prepares each turn so the next one reads it back from the cache, a heavier first message then much cheaper ones. Occasional: it picks the tools by relevance, for a steady cost.
A message sent to a few chosen accounts was then shown to everyone at their next sign-in: the list of recipients was not kept. It is now, and under the form the administrator reads the paginated history of what was sent — date, recipients, expiry.
Until now LIA only remembered what the message evoked. It can now look up a subject found along the way — an e-mail's sender, a place, an instruction given one day. On the phone, that lookup finally answers the question asked instead of returning the latest memories.
Writing to one's own mailbox no longer asks to approve a draft, like the phone call to oneself: « every morning, e-mail me the weather » can run as a routine. The recipient is never a parameter: the connected mailbox, or the account's verified address.
For those who turn it on, a dedicated model rewrites the description of each new image with the techniques the vendors recommend: framing, light, lens, style. What is asked does not change, the text to write in the image stays word for word, and at the slightest doubt the original request goes as it is.
One click on an image sends it to a connection, with a comment if you wish. It lands in their images, as if they had generated it, and in their chat, the comment quoted as written — never turned into a link or a hidden image.
Outside debugging, the logs keep only counts, lengths and identifiers: no searches, no interests, no names of contacts or files. When a database or a service quotes the data it refused, the quotation is removed before the line is written. A test reads every log line in the code and refuses one that would write a person's words.
A calculation, a date or a currency conversion is no longer worked out by guess: LIA computes it exactly, at the day's reference rate, which she names. She can also search her journal for a subject found along the way, tell you what she did and consulted over a period with exact totals, and show you again a file she produced while it still exists.
From the gallery, you can keep an image, a document or a screenshot: the automatic cleanup no longer deletes it, within a per-account limit shown before any refusal. Releasing it gives it a deadline again, never an immediate deletion, and the chat says on every read whether the file is kept or no longer exists.
A message that arrives from elsewhere — another tab, Telegram, a routine, a reminder — appears without reloading the page: the server says so as soon as the message is saved, and the chat adds what is missing without touching what is already shown. Nothing moves while an answer is being written, and a reader who scrolled up is not moved.
An image, a document, a capture or an answer leaves by e-mail, as an attachment, with the subject and words the person chose — LIA writes nothing in their place. It leaves from their connected mailbox to whoever they want or, without one, goes to their own verified address. Each mailbox has its largest size, taken from its provider's documentation and stated before sending.
A routine follows either a schedule or a condition — never both: the person first chooses when it runs, and only that choice's fields are shown. A routine waiting for something no longer has hours: LIA checks the condition itself, day and night, until an optional last day. It runs only on something new, never twice for the same thing, within a daily limit.
E-mails, the Telegram bot, error messages and the application's catalogues are now written in the language of the person who reads them: no more French sentence served by default to a German or Chinese account, no more verification e-mail arriving in English. Every translation table carries the six languages — an automatic check makes sure of it on every change. The hard-coded French that only the model read is now technical English, so that no language is favoured; what remains — a few prompts and labels in French, model-facing texts translated into the six languages — waits for a measurement of what translating them changes.
LIA becomes an on-demand radio station in your language: your day, then the news from the outlets it follows and the sites you add, written, checked and voiced for you while you listen. A fixed grid decides what airs, the models only write, and every sentence shows its source. Nothing is produced when nobody listens, nothing is kept afterwards, and what the session costs is shown while it spends.
JEV helps choose, route or assess within bounded choices, with a hot switch per use and the existing path taking over on uncertainty. Optional uses, off by default, detect an absence of personal references or a rejection of every pending action; neither grants permission to execute. Previews retain canonical results and observers never suppress writes; administrators see context and outcome, paid failures and fallbacks both count, and performance is checked over the complete journey before activation.
The functions that flatten a text for a voice, a notification or a card read some texts in exponential time: 51 characters typed in the chat cost 4.5 s, a 32 KB booby-trapped e-mail froze LIA for 3 s. Every pattern is rewritten linear and two tests hold it, on the server and in the browser alike. Reading a web page now checks every redirect before following it and connects to the verified address, never to a later resolution of the name.
Skills can be searched on skills.sh or at a GitHub address, read one by one before being installed, and kept up to date; the install takes exactly the commit that was read, every file verified. A skill written elsewhere runs apart, with its own files only: never the person's connectors, no image or web content in its answers. A skill can run its own commands in a throwaway copy of its folder, the network only towards permitted hosts, and one the chat writes enters only on the person's click.
LIA no longer holds back a useful notification because a daily cap was reached: the decision model judges whether a signal deserves an interruption. Every pass inside the person's window reaches that decision, and only the window, the pauses between two messages, a meeting in progress and the spending ceilings bound the rhythm. Wakes from an e-mail and anticipated moments follow the same rules.
LIA wakes on a phrase recognised entirely in the browser by a small model trained for its language, without the technical condition that kept the old English "OK Guy" off the iPhone and the native apps; "LIA, stop" cuts her voice. The first model, "Dis LIA" in French, ships in beta because its bench does not yet reach the published thresholds, and the other languages keep the tap. In a Live session, silence puts the assistant on standby: the connection to the provider closes, nothing more is billed, and a tap or the phrase wakes it without losing the conversation.
The blog illustrations are written once, in four widths and a share image, and served as they are: the server resizes nothing any more and the edge cache keeps them. The landing's video is hosted where the operator declares it and described by a manifest read on demand; without one, the section does not exist. Looping, it starts when it is visible, with sound where the browser allows it and muted elsewhere until a click, and while the sound plays the page's title and the section titles beat with the music thanks to a beat map computed ahead of time.
The checks on every change read a single advisory database: the September 2026 review found twenty advisories published by the dependencies' own repositories that no tool saw. A weekly watch now reads those advisories, end-of-life dates, the registries and the browser engine, and every finding is fixed or accepted in writing, with a review date. Python versions move through a single command, after a cooldown, never backwards. Moving off an unmaintained generation can be qualified through an official adapter with unchanged rules and thresholds; compatibility metadata alone is insufficient.
A log line opens its request's trace, a trace opens its logs and metrics, a latency point opens the example that produced it: links measured broken in production now work. The pipeline carrying these signals is watched in turn, with an alert when logs go missing, and every dashboard follows one convention: a week of history and a shared menu.
Answers that carry data — e-mails, appointments, contacts, places, routes, weather — are shown as cards that display everything the source supplied, never inventing a missing value, with the complete detail kept behind a disclosure. The model never reads the card itself, only the authorised facts, so the conversation does not grow heavier. Replying to an e-mail or adjusting a reminder from a card prepares a request tied to the original message and checked again at the click, and a route can open as an interactive map whose cost is announced, then counted.
An optional Simli face accompanies existing speech on a personal key with one audible output. The API controls the connection and its stop; the window shows confirmed or pending closure because silence can consume the plan. The decision remains proposed until provider and real-device qualification; Radio keeps its own player.
Linking two values requires an observation from the right source and account with the expected role; identical words are insufficient. The catalogue retains the read steps needed to start a chain and identifies dependencies without a source. An attempted change invalidates earlier proof both before and after the call.
Explicit requests are anchored to the person's words and checked against observations: value, date, count, operation and completeness. The day and timezone remain those of the turn's start, even after resume. A draft stays pending and an opaque delegation stays unknown; verified gaps reach bounded read recovery and the answer.
Declared independent reads can advance together under a limit, and their results are saved before a possible confirmation. A fresh complete read can serve again within the same turn and context. Changes invalidate reuse. A hard stop before saving can still repeat reads; observations are not shared across turns.
Each person's MCP tools are discovered from their current declarations; only successfully constructed tools are advertised. The server keeps its exact identity separate from simplified routing and callable names. A server-bound task checks its target before confirmation. Older descriptions receive current capabilities without claiming to know the server's entire ontology.
LIA manages its settings and objects through declared operations. Encrypted durable commands bind approved content, actor, origin and expiry; authority, capabilities and preconditions are reread at execution. Source services retain their compare-and-set checks, and claims are token-fenced. Files, OAuth, private input and device work continue in the authenticated browser. Waiting is not completed success; a lost result remains uncertain, without a promise of external exactly-once execution.
Frontal artwork textures bounded relief whose contour and fringe come from source alpha. Hidden anatomy remains approximate; eyes, brows and mouth are projected DOM/SVG layers, and the scarf is deliberately composited in front. Body, face and accessories share the existing rig. Visibility, reduced motion, readiness and graphics context govern resources and fallback to the fixed drawing. Geometry and lifecycle tests certify neither arbitrary occlusion nor real-device performance.
An offline Remotion project preserves chapters, HTML/CSS views, poses and musical accents so the film and feature focuses can evolve together. Reconstructed screens cite native sources and use fictitious data; geometry stays fixed outside explicit focuses, with BIP accompanying the presentation. The manifest can declare a full film distinct from the playlist: its fullscreen dialog suspends the background player. The film is French and its controls are translated; renders, delivered files, music provenance and broadcaster acceptance remain separately qualified.
A server option, empty by default, introduces BIP on the next authenticated visit per browser origin. An explicit identifier changes only style and its marker; visibility, size, positions and later manual choices are preserved. No account avatar column is added. Web Locks coordinates tabs where available; without it, rereading the latest record does not guarantee a simultaneous transaction. Disabling the campaign stops new applications without restoring earlier choices, and cannot reach offline devices.
Nine records about the person — memories, interests, habits, debriefs, open loops, workboard, routines, reminders, kept answers — are read whole, every item citable, under one share of the model's window, and any cut is stated. The portrait is again an analysis of the person on seven facets, never an inventory, and the brief is written as its own sentences; the semantic review, measured rejecting grounded readings, is removed: what refuses invention is structural, every reading cites what grounds it. The budgets are stated targets, never a clamp. A journal change marks the portrait stale, served dated, instead of wiping it; a deleted entry takes the readings it grounded with it. Measured on dev before shipping.
LIA saves, edits and trashes Gmail, Outlook and iCloud drafts without asking: a draft stays in the person's mailbox and reaches nobody, and the trash can be undone. Only sending asks for a confirmation, on a card showing the draft as the mailbox holds it; a draft edited in the mailbox meanwhile is not sent, and a change asked on the card is written before it leaves. On the way, the reply card now shows, and sends to, everyone the reply reaches.
Fish Audio speaks (five models, among them s2.1-pro and drama-3), transcribes meetings and dictation, and its voices are cloned or designed from the administration, under a consent attestation filed in the audit log. Every sentence heard goes through one door that bills it once, in the unit of the engine that actually spoke it; each vendor account has one request allowance, shared by every voice feature; and remote dictation goes to the engine the administrator chose, which the settings name. LIA slips performance cues (a laugh, a whisper, a sigh) into what it writes to be spoken, in the syntax of each engine that performs them, and the radio's voices hold a dialogue in a single take.
Measured in production, the analyzer that followed every failed plan called failures transient that were not, and the recovery loop it waited for would have replayed what cannot be repaired. It goes: a failure is stated in the answer, a passing outage is retried by the client that met it, and a typed counter shows every failed step, including one that happens before a tool is called.
In pipeline mode, the answer was written from a sentence about a tool's data — “2 destinations” — while the travel times, the connections or the next page stayed aside: without them, 0 answers in 9 gave the travel times, 27 in 27 with them. They now arrive as in autonomous mode, bounded and marked as third-party content. And a tool's refusal can no longer turn into a success on the way: the Hue commands said they had switched on a lamp that did not exist.
The old self-efficacy moved only on LIA's self-rating, a single exchange was enough to make a strength or a weakness, and only the final answer read it. Seven domains now keep two separate axes: what a turn verifiably achieved, and the usefulness the person expressed with 👍/👎. From five observations, LIA may verify a point, ask a question or name a limit — without changing any model, tool or budget.
An accepted connection can receive an independent skill, MCP server or plugin copy, disabled and labelled with its origin. The reviewed package is immutable, retries preserve the recipient’s changes, and credentials and grants remain private. An enabled peer skill deliberately follows the recipient-authored policy.
Optional native decisions annotate authorized email and appointment evidence once. Uncertainty stays unlabelled, fees and quotas still apply, and neither a category nor confidence can authorize an action. Fixed corpora and fresh adversarial cases bind the shipped policy to measured evidence.
One Position card groups selected Google Places before their individual cards, including in HTML and Markdown. The interactive map starts only after a click with its cost shown; a source list remains usable if Maps is unavailable.
The API detects sweeps of unknown paths and rejected credentials while leaving normal session and resource errors alone. Redis shares a temporary ban across workers; a cache failure lets requests through and remains visible in metrics.
Every 429 response records the client address resolved through the trusted proxy chain, the method and the path without query parameters. Ordinary access logs stay quiet, and the address never becomes a metric label.
The place panel reuses information already obtained without searching for the place again. The route starts from a permitted browser position, a fresh and dated last-known position, or home: walking up to 2 km inclusive, driving above it, with one recalculation if the actual walking route exceeds the limit. Spending limits still apply and every paid call is recorded, even if the route fails or is cancelled.
The map waits for explicit activation without reserving a large empty space. The same details open in a desktop popup or a phone dialog, each with a single scrolling region. The list and pins share the numbers from the original order; a place without coordinates keeps its number and link without shifting the others. With unchanged content, an activated map stays active during automatic display updates.
The phone submits strict events deduplicated per source. Independent consents, exports, erasure, registers and notifications share the same authority.
Personal initiative is separate from alerts, with its own policy and atomic chat publication. The architecture is approved; the producer still needs implementation before activation.
Observations support episodes and recurring patterns, with an independent portrait, purge and persistent reversible exclusions. Directives constrain initiative; the derived store still needs implementation.
Reads and model calls share a finite envelope and reserved budget. Spending remains accounted on refusal or cancellation; financial guards still need implementation before activation.
The outbound-connectivity probe separates name resolution from the connection and confirms a loss over several paced attempts. A lost DNS packet no longer opens a critical incident: a recovery or a slowdown is reported as degraded, and a real cut names the step that failed.
The next turn now reads the whole history back from the cache instead of writing it again, and what it will read is kept for an hour when a person waits and exchanges often. These hour-long writes are billed at their fair price, and an earlier turn's thinking goes back to the Claude model that wrote it, wherever that model can read it.
Each account now receives at most a few reset e-mails, whatever address asks for them, and a link only serves the account and the password it was issued for. An account that signs in with Google receives a notice instead of a link, an administrator receives nothing, and a burst of requests or sign-ups alerts the operator.
The browser draws the world while Redis arbitrates access and movement; actions retain their native interfaces and approvals. Account name and appearance are shared with consent, activities and home stay private, and peers see only a coarse connection status. Messages stay between their recipients, and consented translations are bounded and accounted.
Sign-up, password sign-in and reset requests now require the token of a Cloudflare Turnstile check, which the server has verified: a script calling the API without a browser is refused. Most visitors see nothing, and when Cloudflare does not answer only the sign-in goes through — a new account or a reset e-mail waits.
What a personal MCP server offers is kept on the account and served again from one message to the next, on any process, while a single one re-checks it in the background. Servers get ready in parallel; one that is too slow is left out of that message, named in a notice, and ready for the next. When the kept copy has outlived its freshness, LIA checks before the call that the tool is still offered in the same form, and otherwise refuses to send it.
When the person designates an item they have just seen by what it is — its sender, a word of its subject — the analysis of the request only says how it is designated; code finds which of the items actually shown those words designate. One: LIA acts and names it in the action journal. Several: LIA asks which one, with a question no model writes, and never guesses; none: a new search.
The person chooses when LIA asks for their approval before an MCP tool: for their whole account, for each server, for each tool — “never ask” staying bound to what the tool declares. Before any change that would make LIA ask less, the page lists what LIA would no longer ask about; nothing is locked. A dedicated agent is asked once before each task whenever one of its tools would ask, and the task then runs to completion; from the chat, LIA can only ask more.
The “Tools” section opens the person’s mail, calendar, tasks, contacts, files, on Google Drive or OneDrive, and lights so they consult them and act by hand: no model, no token, the provider’s own speed. The screen offers only what the provider accepts, and whatever a client gains for it, the assistant’s tools gain at the same time; nothing the person does by hand reaches a register, since it is not an act of LIA’s.
Asking for a game or a small tool gives a page that runs in the conversation, with its file; asking for the code gives the code, and what a person types stays text. The page runs isolated, with no access to the account or to any site of its choosing, under a policy that names no host but the map sources the operator allows. Read back from history it waits for a click, because an endless loop would freeze the tab, and the model only ever reads its title.
The administration offered to tune sixteen agents no turn called any more: a plan runs the tools directly, and production counted not one token on them. Their slots, nodes and prompts are gone; the Emails slot stays, because it writes the messages. A fresh install now starts on models that have a tariff.
Summing up a message, proposing a reply, reading a business card: a click asks LIA one thing and gets a proposal the person reads, never a write to their provider. The act is traced and billed to whoever clicked, and nothing adds a control to a screen with no room for one: the last icon of every bar opens the list.
An ElevenLabs voice session set to a cynical personality spoke like a cheerful assistant: the portal's expression tags prescribed enthusiasm and LIA's own frames asked for warmth. Now every voice of the person — Live, Live direct, the phone and the chat's spoken comment — speaks in the chosen personality, substance first, facts untouched; LIA itself writes the tag palette, the greeting and its tools on the agent. A call to a third party stays cordial.
The result previews no screen showed any more and the initiative's JEV gate, which told nothing apart, are gone, while the initiative evaluator still sees every tool turn. Every JEV threshold becomes a bounded setting the administration screen can change, and every paid judgement is counted over time, so that a threshold is decided on what really happens rather than on a corpus.
An hour no longer conditions a recurring request: a need is recognised by the days it comes back, and the hour only pre-fills. Six kinds of proposal grow from what LIA already records — automating a need, moving a routine relaunched by hand, widening the notification hours, connecting a source… — and one click accepts and carries them out. The chat shows at most one under an answer, chosen by code.
An e-mail, an event, a contact, a task, a file or a light shown in the chat opens in the Tools. The card carries a signed destination, bound to the account and to the source that answered; on the click the server checks that source again and refuses, saying why, when the account changed, rather than open another record that happens to share the identifier.
Every icon goes through one door that draws the account's chosen style, Lucide, Fluent Color or Streamline Flex, without changing what any symbol means, and the system's high contrast keeps its colours. The theme can also turn from light to absolute black by itself at the chosen hours, on the account's clock, without a timer ever writing the profile.
A badge opens Main and named discussions with independent histories and usage figures. Automatic messages keep arriving in Main, and account preferences and learning are shared. Reset and deletion retire the exact runtime and leave a receipt for its cleanup.
Read alone, a message cannot say whether it was answered: the reply is another message of the same conversation. LIA now reads that conversation whenever it lists mail, and tells the same fact everywhere: already answered, a reply left as a draft, a reply received. So it no longer offers to answer an e-mail the person already answered, in the chat as in notifications, the home page, relationships and the Tools.
“Half past nine” names a precise instant only with the zone you say it in, and every hour LIA lost was lost when one travelled without the other: an appointment moved to 9:30 turned up at 10:30. The time and its zone are now a single object, which LIA hands as it is to Google, Microsoft and iCloud with nothing converted on the way, and one rule covers the two nights the clocks change. And every journey of a time, from the screen to the calendar and back, is replayed on calendars simulated from their documentation, in zones far from universal time.
A model knew the present time, never when the earlier messages were written: resumed days later, a conversation read as if everything had just been said, and « the dentist tomorrow », written on a Tuesday, was still ahead on the Friday. Each of your messages now carries the moment you wrote it, in your time zone, and every model that reads the conversation again reads it: the answer, the ReAct loop, the analysis of your request, the compaction summary, the phone call, and what LIA retains about you (memories, interests, commitments, journal), whose deadlines now read in your time zone. Measured on three model families before the code was written, the questions that depend on it went from about 3 right answers out of 21 to 14, 16 and 20 out of 21.
With no search key of their own, a person was searched on Wikipedia alone. LIA now runs SearXNG, a keyless metasearch engine, beside it, on by default (the operator can refuse it): the chat's search, the enrichment of answers, the watch over your interests and the Tools then find their web links there, unfiltered as with Brave, your own Brave key keeping priority. Measured before the code was written: 58 useful searches out of 60 in the six languages, in 0.7 seconds on average. And a watch source that would ask nothing is no longer counted as consulted.
Two people answering the same e-mail used to get the same reply from LIA. The first time LIA writes an e-mail for you, it now learns how you write from your latest sent e-mails — greeting, sign-off, signature, tone, never what you wrote about — and follows it in every reply and new message, including the reply you confirm, which LIA now writes itself when you did not dictate its words. You read, switch off or forget it in the settings. Measured on fictional people before the code was written: replies went from about 42 to 63 marks of their author's style out of 66, without a single fact copied from past mail.
A message sent while LIA was answering — or while a routine ran on your account — was refused and lost. The server now keeps it with its discussion, below the conversation, where you can edit or withdraw it; words written next join it. It leaves by itself, as your message, as soon as LIA has finished normally; if the answer was stopped or failed, it waits for your decision. It is never taken as the answer to a question LIA asks you, and « Send now » stops the answer in progress, then sends it. Every run now says how it ended, and that end, written when the account is released, decides.
What you write while LIA works is often a detail of your request (« only the ones open on Sunday »), and sending it after the answer redid the work. In ReAct mode, your waiting message can now join the answer in progress: LIA reads it at its next step, as your own words, and takes it into account from there, without rewriting anything before it. Until it has read it, you can edit or withdraw it; if it finishes first, it is sent right after, as usual. Your note stays in the conversation, in its place, and the request that the answer, the memory and the next turns keep includes it.
A routine can now run when another system calls it: a home automation box, a code forge, a form service. LIA gives the routine its own address and a secret, shown once; the other system signs each call with it, and LIA serves the call within a minute, reading what it sent as data, never as instructions. A call without a valid signature is refused, a burst is bounded, a retried delivery counts once, and a lost secret is replaced by a new one that retires the old at once. An administrator can switch the capability off; the demonstrator keeps it off.
A routine can now wait for a web page to change: a price, an “in stock” that comes back, an announcement added. LIA reads the public page itself, with no model, and runs the routine only for the lines that appear on it, read as data, never as instructions. A line that leaves and comes back is announced again.
A document LIA generates now uses its format's own mechanisms: a spreadsheet computes with real formulas, a chart can be edited in Excel or PowerPoint, a deck you will present moves soberly, a report opens on a cover page with its key figures, its figures and its clickable sources. The model says what things are and the renderer draws them, in a palette checked for contrast that follows the document's tone. Illustrations are generated images: they come only if you allow them in Settings › Documents, within a budget, and each one is counted in your costs.