fibon

An auditable white-box AI agent for personal use

The name comes from Fibonacci — each block stands on the two before it.

This site is not a README, nor technical documentation — it is a design log.

The seed was planted the moment ChatGPT exploded in 2022, but I didn't truly start building until 2026. This log records every discussion with AI and every round of self-debate since I did — every trade-off, and where each "intuitive design decision" actually came from.

You can be an engineer, or not. This log aims to do more than record the build process and its trade-offs — I hope that whatever your background, you walk away understanding AI a little better, and ideally pause at each decision point to ask yourself: if it were you, how would you design this? What call would you make? I give my own answer almost every time, but yours doesn't have to match mine.

Key decisions and debates are marked with special blocks — see the full field guide in "What do these blocks mean?" below.

How to read this log

Readers range from friends who have never written code to senior engineers. The content comes in three interlocking layers — pick the path that fits you:

What do these blocks mean?

A few kinds of blocks recur throughout the log, each with a fixed role. Here they are in person — what they look like, when they appear:

Quick summary: every chapter opens with one of these — 30 seconds to decide whether the chapter deserves a deep read.

You'll also occasionally see margin notes like the one on the right (or the card above) — passing thoughts, recollections, or asides running parallel to the main line. Skipping them costs you nothing.

What implementation details look like (click to expand) for engineers

Code-level evidence for engineers, proving the design above actually works. Collapsed by default — non-engineers can skip every one of these without losing the plot; engineers who want to verify the claims can dig in.

Glossary for non-technical readers

When the log throws jargon at you, this table translates it into plain language:

Term	Plain-language analogy	Why it matters in fibon
Token	Like arcade tokens. Every word the AI reads or writes costs tokens.	Saving tokens = saving users real money (project goal 3).
Sandbox	Like an isolation ward. However wild the patient gets, nothing escapes the room.	Protects your computer from unfamiliar or malicious code the AI runs (ch. 6).
Coroutine	Like a hyper-efficient barista. While the espresso machine pours (I/O wait), they turn around and take the next order.	Lets fibon juggle hundreds of tasks without freezing (ch. 6).
Atomic	Like a bank transfer. Either the debit and the credit both happen, or neither does — never "half-transferred".	Ensures safety limits and state can't be bypassed mid-crash (ch. 2).
Vector similarity	Finding data by intent and meaning, not literal keyword matching.	The AI hears what you mean even when you don't say the exact keywords (ch. 3, 4).
Session	One chat window, or a single conversation thread.	fibon's biggest target pain point: an AI that remembers you across chat windows (ch. 3).
Skill	A work manual written for the AI: how to perform a specific task.	Auditing whether the LLM actually followed the manual is the core of ch. 4.
Scope	Who a memory belongs to: personal, a specific project, or global.	Keeps memories from different contexts from contaminating each other (ch. 3).
Ingest	Like the brain organizing the day's memories into notes while you sleep.	The background process that turns messy conversations into structured memory cards (ch. 3).
ADR	Architecture Decision Record — a written memo of "why we picked A over B at the time".	Every major fibon design has one; the log cites them constantly.
MCP	Model Context Protocol — the standard plug that lets AI connect to external tools.	Ch. 4 and 6 dig into how fibon splits "trusted" from "untrusted" tools with it.
A2A	Agent-to-Agent protocol — a standard for AIs built by different teams to talk to each other.	Already supported; future assistants can cooperate across products.

The four project goals

Every design trade-off in fibon ultimately gets tested against these four:

🛡 Make AI safe and controllable — through engineering

We don't beg the LLM to behave or pray a prompt holds. We rely on code-level hard boundaries, human approval before critical operations (human-in-the-loop), and complete audit trails with no blind spots.

🎯 Curate exactly what the LLM sees

The point isn't letting AI "see more" — it's "see better". We'd rather have it act precisely on the 5 most relevant long-term memories than stuff 50 noisy ones into the context.

💰 Slash token costs

Caching, dynamic tool selection, and layered filtering put every cent where it counts — expensive models shouldn't burn for nothing.

🤝 Make AI a true personal assistant

Not a disposable coding tool, not a stiff service bot — a companion that remembers the big and small things over the long run. Every conversation accumulates into your personal knowledge base instead of being thrown away.

Chapters

📖 Written for everyone — key decisions highlighted in sidebar blocks. Each chapter opens with a quick summary; skim it first, then decide whether to go deep.

Chapter 1

Why I'm Building My Own AI Assistant

A seed planted the moment ChatGPT exploded — and why I didn't start building until 2026

Chapter 2

Is One AI Not Enough?

Why fibon splits the Butler from the Assistants, and why the rules of delegation must be hard-coded instead of merely "asking" the AI nicely

More chapters are being translated — the Traditional Chinese version is the source of truth.

Field Notes

📰 A different clock from the serialized chapters — principle-level teardowns of AI infra incidents, each ending with how it maps onto fibon's design: which bug classes have no surface to attach to, and which defenses we still haven't built. Updated as events warrant — full list here.

📅 2026-06-07 ⏱ 14 min