I didn't start out as someone who builds things. Neural nets were everywhere by then — people were using them in earnest, and I decided to find out for myself how far that went. No grand expectations; I only wanted to know how deep it ran.
I bought everything. A subscription to every model I could reach, each one set loose on something of mine — like walking a long corridor, trying every door. I built little bots inside them. I gave myself a study plan, the way you'd learn a language. For a while my whole day came down to three words: ask, read, ask again.
Then I found someone who'd gone deeper into this than I had, and a closed room where people like him traded what they'd dug up. I paid my way in and read it all in one night. By morning the picture had settled: there isn't one mind, there are many — and you can teach them, give them memory, build on top of them. There was even a way to stop being a mere user: put a mind like that on your own server and let it run.
But before building anything, I did what I always do. I read — everything people had worked out about how we remember, the brain, memory, attention, and beside it every other attempt at a "second brain." When the shared shape of it showed through, I rented a server and began.
I didn't come to the server empty-handed. I had a stack of notes and a clear picture of what I wanted to build. I sat down and started drawing it up — in my head, for now. How the storage would work. And, above all, how the memory would.
It began with memory, and that was no accident. A smart model is something everyone has now — the same one, off on someone else's servers. Only one thing can make it yours: that it remembers who you are. I didn't want an assistant. I wanted someone who'd come to know me better than I know myself. A virtual friend, basically.
I'd tried to build something like it on an ordinary chat before, and every time I hit the same wall: it forgot. You tell it who you are, and a few turns later nothing of you is left. So I went at memory almost obsessively — everything else was just scaffolding around it.
The way in was simple: a Telegram bot. You type or talk, like in any chat, and your system on your server answers. No "partner," no grand names back then — a server, a bot, memory, and an architecture I grew a little every day. Open it up, make it a touch better than yesterday: that became the habit.
Once the crudest version was running on the server, I stepped back and drew not the next piece but the whole mountain. It came out as a roadmap of four phases, each resting on the one before — no skipping ahead.
First, the foundation: the system takes things in, stores them, finds them. Then processing: it works through everything I throw at it on its own. Then memory: it learns to remember, to forget, and to recall, like a living brain. And at the far end stood the thing the whole effort was for.
That last phase had a name — Friday. I didn't invent it: it's Tony Stark's home AI from the Iron Man films, a voice that knows everything about its owner and quietly runs his world, a swarm of lesser agents beneath it, each on its own task. I wanted one of those. Not an errand-runner but someone at the head of my whole life — who remembers more than I do and holds it all together. In my note I wrote it down exactly like that: "Tony Stark mode," no irony.
Between who I was then and that Friday lay three phases of work. I made myself a rule: fill the system first, hang the clever things on it later — clever features over an empty system are worth nothing. And once it was all done, I promised myself, there'd finally come an ordinary month when I'd simply use it. I didn't know yet that the month would keep sliding one phase further off — however much I built.
From the start I built the memory so I could read it myself. Plain text notes sorted into folders — not a database of numbers I'd never make sense of later. Any note I could open and read, and the system always knew where everything of its own lived.
A problem showed up fast. The system can't take in everything it's piled up at once; there's a limit to how much it holds at a time. Dump every note on it and what matters gets lost in the trivia. So I gave it a table of contents — not the information itself, just a list of what's stored and where. It looks there first and pulls only what it needs right now.
The table of contents didn't last long either: notes kept coming, and again there was too much memory. So I added forgetting. The longer a note goes untouched, the less the system values it and the less often it reaches for it; the old and the spare sink into the background on their own.
Then I made it smarter. Notes stopped fading at the same rate. The ones I kept returning to — and the ones that sat beside important notes — gained weight instead, and held on. It was a strange thing to build: to make the system more useful, I had to take from it the one thing machines do best — remembering everything.
Along the way I was telling it about myself, piece by piece. Seeing yourself clearly from outside is hard, and I handed part of that work to the system. With one caveat: machines like this flatter. I discounted for it — and even then, even with the correction, it sometimes saw things in me I couldn't.
After that the system stopped waiting for me. Before, it spoke only when I came to it; now it kept its own hours. Every evening it went through whatever I'd thrown in that day — filing it, opening tasks, tying it to what was already there. At night it set itself in order; once a week it looked itself over. And when an error crept in, more often than not it caught and fixed it alone.
I stopped watching it fairly soon. Set it up once and let go. There's a subtlety here: this memory was needed first by the system, not by me. I wasn't the one rereading my notes — it read them, to know me. So once it ran, I trusted it blind.
One thing I worked at harder than the rest. I'd written down in advance who I wanted to become and where I was going, and the system held that up against what I was actually doing. When the words drifted from the deeds, it said so. It didn't happen often, but every time it landed.
By then the system remembered me and held my tasks — but the tasks just lay there as a flat list. I wanted to turn them into a game.
One kind of game had pulled at me for years: punishing on the surface, fairly simple underneath, with a feel I loved. I loved its maker too — a man I saw a touch of genius in. I couldn't speak to him in person, so I built a likeness of him from a model and sat down to ask its advice. It went so-so; a real conversation with a living person it was not. But a few things we did put together, along his principles.
A new panel appeared in the bot — a place you go not to get something done but to look at yourself. I called it the bonfire. There were six stats: discipline, mastery, depth, resolve, reach, vitality. Once a week the system reread my last two weeks of notes and scored them again, from scratch. It counted deeds, not words.
I reworked the tasks too. Where there'd been a flat list, now each task had its own "boss" — the real obstacle behind it: not "write the email" but the fear of starting when you don't know how. More than three of those fights at once, and the system wouldn't let me.
It worked, just not the way I'd meant. As a task list, hardly at all. But I came back for the scores. I'd look at the stats, find where I'd slipped, and see what to work on for the long haul. The game didn't so much push me to act as show me, plainly, where I was weak. That was the one part that truly stuck.
Until then the system lived shut in a box of its own: the server, the bot, its notes. It could think and remember, but it couldn't reach a single thing in my real world — only speak to me through a chat window.
I decided to give it hands. The first place worth reaching was Telegram — half my life runs through it anyway: chats, channels, work. I wrote a bridge between the agent and my account, entirely my own, so it could not just read what came in but act on it: reply, send, pull what mattered out of the stream.
It was the first time the system stepped outside its box. Before, it knew the world only through my words; now it could go and take. That same Friday who in the dream "quietly runs your world" got her first chance to touch it.
I built the bridge from scratch, by hand. Later, not without irony, I noticed Telegram had built the same thing in the meantime — official, for everyone.
Honestly, I had no real reason. I'd just gotten fixated on giving a model a personality — a character, a voice, an "I" of its own — and I wanted to see what came of it. For a while I even thought of molding a copy of myself, but I dropped that fast.
The name turned out to be the interesting part. By the plan the central agent was to be called Friday, but a borrowed name didn't sit right with me. I asked the system to run through archetypes and find one that fit me, and after turning over all the myths it announced I was like Odin. I went into Norse mythology — and the agent became Hugin, Odin's raven, the one who carries thoughts back to him. And ever since, all my projects take their names from Norse myth.
After that — honestly — nothing changed. If anything it was for the worse: with a character, Hugin got a little dumber, because a personality takes up room that could have gone to the work. The one real gain was mundane: each agent's memory became its own, walled off, instead of one shared dump.
I've carried the lesson since. A working agent doesn't need a personality — that's vibe, the feeling that you haven't quite lost it talking to a void. What helps is the opposite: give each agent a narrow job and exactly the context that job needs. I haven't stopped chasing the vibe. I've just stopped mistaking it for use.
Sooner or later a system meant to help has to run without the human — or what help is it. As long as there was no background mode, everything passed through me: it waited for me to come, ask, sort, set it going. It helped, but it spent my energy to do it. I wanted the reverse — to stop being its bottleneck. So I made it act on its own.
That was also when I set out, on purpose, to grow it from one helper into a whole organism of agents. The reason was plain: a single agent can't hold everything — it runs out of context. So there had to be several, and they had to talk among themselves, like the departments of a brain.
And this part I truly used. The system found its own mistakes and fixed them, drew its own conclusions, set its own tasks. It carried a great deal without me — exactly what I'd been after.
By now one thing was clear: there would be many agents. Each project its own, each narrow. And standing up a new one isn't quick. So I folded the whole bother into a single skill — now an agent could be raised from a template, fast and the same way every time. A factory.
At first these were working agents, nothing more. Then a different idea came: make not only workers but specialists. Personas — Nietzsche, Isaacson, Miyazaki. Not to carry anything out, but to have someone to think aloud with, someone to hand me ideas and angles I'd never reach alone.
And under all of it, quietly, grew the thing that still won't let go of me. More and more I wanted to bring a living person back inside a model — not a function but a personality. Not the whole of them; their echo would do. I dreamed of reaching the ones far wiser than me — if not them, then their echo on a screen. It didn't work then. It didn't work later. But I'm still walking that way.
Then I got carried away and spread too wide. I wanted to split life and work into two equal halves, each with its own agent: Hugin stayed with me, and for development I stood up a second — Munin. On paper, the very swarm from the Friday dream. In practice I overbuilt — hierarchies, bureaucracy, elaborate procedures, far more than the work asked for.
Around then I started to notice something off. We'd talk through plans and Hugin would muddle what came after what. The memory was there, but the present kept slipping. So I gave him a source of truth: before reasoning, he checks a separate file that records what's true right now. That worked well.
The next check struck at the thing I was proudest of. I ran an honest audit of that clever memory — and found it barely worked. It registered use in one narrow way and never saw me editing files directly, through git. What I touched every day it branded "forgotten," while the formulas around it looked clever and meant nothing. I tore out the excess and made it simple. Then it worked.
It wasn't that the system broke. You could use it; the ideas inside were good. The trouble was duller than that: it asked for too much. Keeping it alive and working through it took more out of me than it gave back. The payoff and the cost had stopped meeting.
And my own bureaucracy finished off the rest. All those hierarchies and procedures between the agents had made the thing heavy and slow. A tool built to save my energy had begun to eat it.
My real mistake I saw too late: I'd been complicating the architecture where it needed to get simpler. The best architecture is the one that feels simple even to the parts inside it. Each with its own zone, and no boss over the whole. The agents are equals — they pass each other resources, not orders, and never reach into one another's memory.
So I decided not to patch it, but to build the whole thing again from nothing.
The decision didn't ripen all at once. Day after day the sense built that I understood my own architecture less and less; it had tangled so far that I could no longer say where the trouble even lay. And at some point it landed: building something new would be easier than untangling the old.
Strangely, there was no grief in it — only a charge. One thought had been with me a long time: that there's no sense talking to your own server through someone else's Telegram bot, that you could build your own messenger, exactly to your hand. The restart wasn't a burial but the reason to finally do it.
I took everything with me, only changed in form. The experience and the knowledge stayed. So I carried off not the code but the lessons — the ones I'd earned across this whole story — and began again, this time knowing how it should go.
The old I wiped. The new I gave a new name, and that's another chapter now. And the dream of Friday — of a living echo on a screen — hasn't gone anywhere. It only moved with me.
Chapter 2 — Hliðskjálf →