CASE STUDY · PRODUCTS & PLATFORMS · AGENTIC AI IN PRODUCTION

AIDA: a self-extending AI agent that ships its own features

Every AI assistant has a hard edge: the request it can't handle yet. Most stop there. AIDA doesn't. When my family asks it for something it can't do, it interviews me, writes a spec, generates the code, passes its own CI and audit gates, and hands me a pull request I approve with one tap in Telegram. Then it deploys the new capability to itself.

What AIDA is

AIDA is a personal and family AI assistant that runs entirely on my own infrastructure. It lives where my family already is: a Telegram group and a mobile web app (a PWA). Day to day it handles the operating system of a household (expenses, savings goals, to-dos, reminders, notes, receipt capture), plus live web research and on-demand financial analysis when someone asks a harder question.

It has no public URL, deliberately. This is a private family system, and the privacy is architectural rather than a settings toggle: all data sits in my own PostgreSQL, and the intelligence comes from my own Exybit AI engine, a proprietary agentic core running on my stack. The family's financial records and reminders never leave infrastructure I control.

Two brains, one assistant

The most consequential design decision in AIDA is that it is two systems wearing one interface:

• A fast, deterministic system of record: typed actions, schedulers, and PostgreSQL. Logging an expense, setting a reminder, ticking off a to-do: these are database writes and scheduler entries, executed the same way every time.
• An on-demand agentic layer for the open-ended work (web research, financial analysis, and code generation), invoked only when a task actually needs reasoning.

Every incoming task is routed to the right brain, and the routing is the point. A reminder must never hallucinate. "Remind me on the 15th" is not a judgment call; it's a scheduler row with a timestamp, and it fires because a scheduler fired, not because a language model decided to mention it. The agentic layer is reserved for questions where reasoning adds value, and even then it reads from and writes to the same deterministic system of record. Probabilistic where that buys capability; deterministic everywhere correctness is non-negotiable.

The self-extending pipeline

The headline capability is what happens at the edge of what AIDA can do. When I ask for something it has no feature for, it skips the apology and starts an interview. It asks clarifying questions until it can write a concrete spec of the missing capability. Then an automated pipeline takes over:

The spec drives code generation against AIDA's own codebase. The generated change must pass a CI gate; if the build or tests fail, an auto-repair step feeds the failure back and tries again. What survives CI then goes through an AI self-audit: a review pass over the change before any human sees it. Only then does the pipeline open a pull request, and I approve it with a single tap in the same Telegram chat where the request started. On approval, the new capability deploys to the running assistant. The system that took the request is the system that grows to handle it.

Note what stays human: the merge. Everything up to the pull request is automated, but nothing lands without my explicit approval. The pipeline was built that way on purpose. Autonomy in the loop, authority at the gate.

Honesty by construction

A system that writes its own code has one failure mode worse than a broken build: claiming it did work it didn't do. AIDA is guarded against this by construction; prompting alone wouldn't be enough. It cannot report a capability as shipped unless the pipeline actually carried it through; guardrails stop it from narrating success it can't back with a merged change. When a build fails, the failure routes back to me with the real reason and a link to the pull request, quoting the actual CI output instead of a soothing paraphrase. An assistant that manages a family's money has to be boring about the truth.

It reviews itself

Self-extension covers what we ask for. Self-auditing covers what we don't think to ask. AIDA logs how it is actually used and runs a proactive self-review over that record: where requests fall through, which features go untouched, where the same friction repeats. It comes back with concrete improvement proposals instead of waiting to be told. The same pipeline that builds requested features is available to build the ones it proposes, behind the same one-tap approval.

One face of it is public

If you've used the chat assistant in the corner of exybit.org, that's AIDA. The site widget is one face of the same system: the same engine, the same architecture, pointed at a public audience instead of a private family group. The household side stays private; the public side is the demo.

What this proves

AIDA is small in audience and large in what it demonstrates: agentic AI engineered like production software. Deterministic cores where correctness matters, agentic layers where reasoning pays for itself, CI and audit gates in front of every self-made change, guardrails that make honesty structural, and a human holding the merge button. That's the discipline I bring when Exybit builds agentic systems for businesses, because I've been running one on my own family, on my own servers, every day.