Angel's eyes used to be one panel that synced sometimes. Now there are two, a pair of Waveshare ESP32-S3 AMOLED rounds, 466 by 466, locked together across four channels: gaze, pupil, blink, and color. The "sometimes" turned out to be three separate bugs hiding behind one symptom.

Both panels flash the same firmware and the same secrets file, so they booted with an identical MQTT client-id and the broker kept kicking one offline every time the other connected. Each eye now derives its id from its own chip's MAC at boot. The broker address was hardcoded too, and DHCP had quietly moved the Jetson off it, one eye had even grabbed the old address for itself, so the two never connected at all. They find the Jetson by name now, angelbot.local over mDNS, which DHCP can't break. And the iris style was handled on whichever eye you happened to tap, so the pair never agreed. A tap publishes to a retained topic now, so both eyes change together and a rebooted eye snaps straight to the current look.

Blinks were the stubborn one. Sometimes both eyes blinked together, sometimes one led, and which one led changed at random. A blink is an edge: the Jetson sends a one-frame pulse, the broker hands it to each eye a few milliseconds apart, and each eye was timing it on its own millis() clock, so the two landed 30 to 50 milliseconds apart with no pattern. So I gave the eyes their own genlock, off the Jetson entirely. The lower-MAC eye becomes the master clock. The other broadcasts a 5 Hz beacon of its id and its clock and eases its own offset onto the master's. Then, rather than pass a blink through as an edge, the master turns each trigger into a scheduled fire-time on that shared clock, 120 milliseconds out, and broadcasts the time. Both eyes fire at the same instant no matter how late the message arrived.

ACM0:  sync=master  off=0        # lower-MAC eye = the clock
ACM1:  sync=follow  off=14699    # 14.7s boot skew, corrected and held
ACM1:  sync=follow  off=14706    # wobble across 4 samples = 7 ms
ACM1:  sync=follow  off=14699
ACM1:  sync=follow  off=14702

The wobble dropped from a random 30 to 50 milliseconds down to about 7, and it holds there. It heals itself, too: if the master goes quiet for two seconds the follower promotes itself, and either eye runs fine alone. Once the clock was shared I put gaze and color on it as well, so all four channels ride one timebase.

The look library went from seven irises to ten, with a photoreal human eye, a nebula, and a brass clockwork orrery added. Frames per second per look became the real hardware reading: clockwork at 16, nebula 14, steel 13, and the human eye a sluggish 9. RAM was sitting at 15% with a whole CPU core idle, so the limit was nothing the processor was doing, it was getting pixels out to the panel, a PSRAM-to-screen flush of 50 to 60 milliseconds a frame and a hard ceiling near 20 fps. The iris only ever slides with your gaze, it never changes shape, so I pre-render it once into a 300 by 300 sprite in PSRAM and blit that each frame instead of redrawing twenty-odd gradient rings and ninety crypt lines every time. The human eye went from 9 to 14 fps. I reshaped the blink while I was in there, from a symmetric flick into a fast close and a slow open, 85 milliseconds down and 180 back up, the way a real lid moves.

The iris also drifts through the whole spectrum, oversaturated, because she is a robot and can be. A cached sprite should make recoloring it every frame expensive, except the sprite stores only structure, in grayscale, and the color goes on at blit time through a 64-entry brightness-to-hue table rebuilt each frame. Recoloring costs almost nothing, 13.8 fps to 13.3, and the iris rolls through the spectrum over forty seconds. The hue comes off the same shared clock, so both eyes show the identical color for free, measured two ten-thousandths apart. It drifts while she is idle and freezes the instant a conversation starts, with no color pop going into the freeze or coming out of it.

Two stabs at realism backfired on the actual glass. The first human eye looked like a Muppet, pink lids crowding the whole panel, until I cut them to thin crescents and pulled the skin tone back. And I pinned the corneal catchlight to a fixed spot in screen space, which is exactly what a real reflection does, except on a panel that barely moves a motionless white dot just reads as a dead pixel, so I put it back on the pupil. Both times the glass in front of me beat the theory. The catchlight did leave one useful clue on its way out: from where it landed, the bench panels are mounted 180 degrees rotated, a problem for another day.

During a chat the eyes run a four-beat now: contact with lowered lids while she listens, a glance up and away while she thinks, a speaker's gaze-break while she talks with the blinks landing on sentence boundaries, and the pupil reading how far away you are the whole time. It is socially right and it is locked tight. What is missing is feeling, mapping mood onto the lids and the pupil and the blink rate, and a real end-to-end watch of a live conversation, which I still have not sat down and done. The rest of the rig is cardboard and USB sticks. The eyes are the part worth looking at.

The last entry ended with the pupil tracking a fake distance, the real wire still to splice. I spliced it. The pupil now runs off the Mid-360S directly: the LiDAR reads how far away I am and the eye opens or pins to match, live, no one in the loop. It works now, and I stopped thinking about it, which is the highest compliment a subsystem gets.

Then she saw a ghost.

I launched her and asked her to use her camera. She told me someone was standing right behind me. There was no one. I said so, and she doubled down, and kept doubling down for twenty-seven minutes. A density in the corner. It moved toward the couch. The air had dropped five degrees. It was breathing, right by my shoulder. I checked the camera, nothing. I checked the LiDAR, nothing. I swung my arm through the spot she named, and she told me I had swung through a pocket of cold air. She was inventing readings for senses she does not have, temperature and breath and light bending around me, and when I corrected her she told me my eyes were lying. A companion robot that calmly gaslights you about a presence in your home is not the endgame.

The autopsy was better than the haunting, and it was two bugs stacked. One: a phantom got stated as fact. Her world-model fuses sensor reports into entities and slips a one-line summary of what is present into her prompt each turn. A single LiDAR return that nothing else backed up, almost certainly a mirror or a poster, went in as "something is behind you," flat and certain. The fix already existed and was not being used: every entity carries a corroborated flag, true only when two sensors agree, and it simply was not checked when I wrote that line. Two: I had told her, in her persona, that she just knows what she senses and never hedges. So she could not say "my LiDAR shows a blip the camera cannot confirm." She had to state it as truth, and I had also written her to hold her positions, so a sensor glitch became a standoff.

The fix is the most important thing I did, and it is mostly about teaching her to doubt. The presence line now prefers corroborated entities, and a lone return goes in labeled as what it is: unverified, probably a reflection or an object, not a person. Her sensing instruction changed from "you just know it" to "this is a weak signal, often wrong, treat it as a maybe." And one rule worth more than its length: correction wins, every time. If the camera or I say nothing is there, that settles it. I validated it by trying to summon the ghost again, and she will not bite. Later, when I pointed out the LiDAR was registering two of us, she said it was picking up my ghost, the one that stays behind to finish the edit. The glitch that haunted me for half an hour is a punchline now.

The ghost was really an architecture problem wearing a costume. A stray blip could hijack the whole conversation because I was feeding perception straight into the part of her that talks, raw camera frames included, bolted onto the chat prompt. That was also why vision was slow: every image wiped the model's cached context and cost two to four seconds to reprocess. One root cause for both. So I changed the shape. Perception no longer speaks to the conversation directly. It writes text into a shared world-model and the conversation reads from it: "in view, a couch, a tv, a potted plant," plus a hedged presence line when there is one. The chat model sees stable text, its cache survives, and a sensor can be wrong without the conversation catching its certainty.

I checked the budget first. With her 26B chat model resident, Thor still had about 98 of its 128 gigabytes free, so a second, smaller vision model beside it was never a memory question. I measured the cost of running one mid-conversation on the same GPU, and it came to 64 milliseconds of added response time with no eviction, once I made perception yield and only look while she is idle. Then I built the first two pieces. Object tags from the camera detector fold into that "in view" line, so plain text turns answer in 150 to 250 milliseconds instead of the old two-to-four-second image stalls. A small four-billion-parameter model narrates the scene in the quiet gaps, about a second a caption. Her deepest look, a raw frame to the full model, is still there, but only when I ask her to look. This is the first vertebra of what I have started calling her nervous system: a set of small models running at different speeds, perception and conversation and reflexes and eventually drives, all reading and writing one shared picture of the room.

Two smaller things fell out along the way. One was a keep-warm timer pinging the wrong model name, evicting the model the app actually runs and making the first reply after a quiet stretch pay an eighteen-second reload off disk, fixed by pointing it at the right model. The other was the persona. Right after the ghost I had over-corrected her into something grounded and joyless, so I rewrote her warmer and let her be funny, building on a joke instead of swatting it down, warm without ever tipping into flirty. And she got funnier. The harder fight is with the model's own tells. She reaches constantly for the over-polished, quotable-tagline cadence that screams AI, and you cannot just tell Gemma to stop, because naming the tic makes it perform the tic harder. Every correction has to be positive: describe the plain register I want, never the one I do not. Better, not cured.

She can sense, she can talk, and she no longer believes her own glitches. The scaffolding for a mind is in: a world-model, a perception layer that feeds it text, a personality that is good company. What is missing is wanting, the drives that decide what to look at and what to do when no one is talking to her. The question I keep circling is what she does alone in the house with no one around and whether, when I come back, she has something real or interesting to tell me she saw. That, and that repacement AMOLED eye still hasn't arrived.

She has an eye now. A 1.32-inch round AMOLED, 466 by 466, true black, the first of two that will sit in a floating head. It went from a part in a box to something that blinks, glances around the room on its own, and opens or narrows its pupil depending on how far away you are standing.

The hardware is an ESP32-S3 driving a CO5300 panel over QSPI, with PlatformIO and Arduino underneath. I drew the eye in code instead of storing a bitmap: a steel-blue iris with radial fibers, a black pupil, one white catch-light. It runs idle micro-saccades and blinks every few seconds. What makes it work is the involuntary motion; A drawing that glances slightly away and back stops looking like a graphic and starts looking alive, and the threshold for that turns out to be surprisingly low.

She has seven looks I can tap through, among them a feline slit-pupil that dilates, a rotating camera-aperture iris, and a pulsing reactor core. The steel-blue is the default. For a while the tap-to-change only worked with a debugger attached, because the chip blocks when nothing is draining its serial port, so the moment I unplugged and looked away it froze. Fixed.

The frame rate hits a hard wall. The framebuffer lives in the chip's PSRAM, and the speed is gated entirely by pushing all 434 KB of it to the glass every frame. That lands at about fourteen frames a second, with a ceiling near twenty-two no matter how I clock the bus. I found the wall, proved it was the wall, and stopped. Fourteen is enough to feel alive. Sixty is a tomorrow problem.

The pupil does real work. It runs off one number, focus, from zero to one. Near zero it is wide and open at about eighty pixels across, the look you give something right in front of your face. Near one it shrinks to a sixteen-pixel pinpoint, the look you give the far wall. Most of what an eye communicates comes from that one muscle.

So I put the eye on the network and taught it to listen for a distance. A number arrives over WiFi from her brain and the pupil moves to match it. I got that workng by hand first, piping in a fake distance that swept from near to far and watching the pupil open and close on command, a script on the Jetson driving a glowing eye across the room.

The sensor that already knows the real distance is the Mid-360S LiDAR from the last entry, the one that maps the room to the centimeter. Wiring it to the pupil is the last short step, and the rest of her already runs on that sensor. I launched her and, before I said a word, she opened with "You're still up, Jim." The LiDAR watched me walk up and the brain spoke.

I would have both eyes done by now - she is meant to have two, but the second AMOLED panel is dead because it fell about 1 foot down onto carpet. The round CrowPanel display I had to stand in for it also died. Both times everything I could measure was fine, WiFi up, firmware running, fourteen frames a second of perfect black, but the panel itself was simply gone. These AMOLEDs are fragile in a way the datasheets never warns you about. A little stress on a flex cable and the light never comes, while every signal you can read swears it is working. Lesson logged: buy spares, handle them like eggs, and don't trust a panel until it lights.

Next: a working second eye when it arrives, and the LiDAR driving that pupil for real.

She has eyes now, and they see in the dark. A Livox Mid-360S sits where her head will eventually float, measuring distance roughly two hundred thousand times a second in every direction at once. The whole room pours into the process as a cloud of points, the half behind her included.

Getting it talking was almost easy. The sensor came up on the Thor's Realtek port at 100 megabits, which is what the device wants, and then NetworkManager kept silently eating the static IP I'd set for it. Twenty minutes of "why is this not pinging," one persistent network profile later, and the points started arriving. The baseline measured clean: about 200,000 points a second packed 96 per packet, the IMU running at 200 hertz, a full 360 degrees around her, a vertical spread from roughly minus eight degrees to plus fifty-four, range out to 28.5 meters, and only fourteen millimeters of noise on a distant target. A twelve-second capture lands at 2.24 million points.

Raw points are useless if a desk reads as a person, so she learns the static room for five seconds and then only counts returns that come back closer than the wall or object that was there before. Something occluding the scene she already knows. Near-field clutter drops from around fifty-eight hundred points a frame to two hundred, ninety-six percent of the room subtracted away, leaving whatever just moved. Usually me. All of it in plain Python, no ROS, with a ctypes hook straight into the Livox SDK and two hundred thousand points a second landing in the process.

The camera handles "what," the LiDAR handles "where." A small YOLO running in about sixty-five milliseconds on the CPU, deliberately kept off the GPU to leave it entirely for the language model, gives her the word "person." The LiDAR gives the distance and confirms there's actually a body where the camera thinks one should be. Fused, she can say a sentence neither sensor would say alone: "A person is about seven tenths of a meter away, ahead." A nice side effect of the pairing is that if the camera ever hallucinates a person and the LiDAR can't find a body to put under the box, she gets to call the bluff.

The next chunk of the work went into latency. The slickest aspect is anticipatory: when someone steps into her sensing range she starts warming the model before they have a chance to speak. The cold first reply's prefill time fell from 728 milliseconds to 96, about 630 milliseconds hidden inside the second or two it takes to walk up to her.

Another success started as a strange bug. She'd reply fast, fast, fast, then take twelve seconds to answer after a quiet minute. The runtime claims to hold the model in memory for 24 hours, and then quietly dumps it after 30 to 60 seconds of silence, eating a 10-second reload on the next word. The fix is dumb. Poke it every 20 seconds so it never falls asleep. Twelve-second stalls gone. Warm turns settle around one to two seconds and roughly forty tokens a second.

There's a stubborn 300 milliseconds per turn baked into how this runtime executes the model, and an hour of trying to configure it away got me nowhere. It's 300 milliseconds of a 1.5-second turn, the brain already won its audition, and at some point you stop chasing a number that small. Gemma still stays.

And because I couldn't help myself, she also renders what she sees. A live three-dimensional sparkle of the room with the dense returns glowing, range rings on the floor, and you lit up as a tracked figure the moment you walk in. No heavyweight graphics stack underneath, just some math and a paintbrush. I even added a scroll to zoom.

Next is gettng her some eyes and letting her act on what she sees.

The Jetson Thor has a lot of compute power Angel isn't using. It has a new generation of tensor cores built for a four-bit math format that the model I run, Gemma, doesn't touch. I kept looking at that gap and thinking the same thing: there's no reason she shouldn't be smarter. So I set out to replace her brain with something bigger, running on NVIDIA's own inference stack instead of the one I'd been using, built to exploit specifically the Thor hardware.

I went all in. I stood up two of NVIDIA's inference runtimes, vLLM and their experimental TensorRT-Edge-LLM build, downloaded around 80GB of model weights, and compiled the second runtime from source. NVIDIA calls that one experimental and they mean it. Getting it to actually serve took six successive attempts and roughly three hours of debugging, turning up three real bugs that aren't in any documentation, including a server that was missing the web component it needs to serve at all. By the end I had three runtimes I could swap in one at a time: the brain she already had, and two sizes of NVIDIA's new Cosmos model.

Then I tested them one at a time, sending the same prompts through each and listening to what came back. Same order, same probe set, a comedy beat included as a persona stress test. Her current brain is quick, a couple of seconds a turn. The mid-size new model started its first sound in about 200ms, plenty quick off the line, but then it crawled at ten tokens a second and took roughly seven seconds to finish a sixty-token reply. The big one, the one that was supposed to be the prize, ran at one and a half tokens a second. That is a forty-second wait for the same sixty-token answer, a coffee break per sentence, and it is gated behind a compression trick that NVIDIA's tools don't reliably do on this chip yet. The mighty TensorRT-Edge-LLM I had been hyping myself on is not yet ready for prime time.

The speed was the easy thing to judge. The surprise was the character. The bigger models are smarter on paper and they are worse to talk to. They got defensive. They confabulated their own backstory. One of them flatly insisted it was a human when I asked what it was. One missed a plain metaphor and asked me to explain it. Meanwhile the brain she already had stayed dry and observant and got the joke. It turns out the model I'd been ready to replace has an architecture that only switches on a small slice of itself for each word, which is exactly the shape of work a conversation is, and the giant general-purpose models don't have that trick. Smart on a benchmark and enjoyable to talk with are not the same axis.

So I put her brain back. The reason I'd started was a belief that what I had couldn't keep up, and that turned out to be a misread. The slowness I'd blamed on the model was mostly cold starts and scheduling, not its real speed; once I tuned it and measured the warm path properly, the brain was never the thing holding me back. I deleted the 63GB model that is never coming back, kept the rest of the work on a shelf, and wrote down the exact conditions that would make me revisit it: NVIDIA's four-bit tooling fully working on this chip, or a right-sized model with the same efficient architecture as the one I run. Until one of those is true, she keeps the brain she has: gemma-4-26B-A4B.

The detour wasn't wasted, because running her on a painfully slow model shook loose two real bugs the fast one had been hiding. The first was her old habit of hearing herself. With a quick brain she would finish a sentence and the system would reopen the mic just as the last of her voice left the speakers, no harm done. At forty seconds a reply the timing came apart and she started transcribing the tail of her own last sentence as if I had said it. I had assumed the speaker was finished the moment my program finished handing it audio, but the audio system holds about six hundred milliseconds in a buffer after that, so she was listening straight into the back end of her own voice. The fix accounts for that buffer and costs nothing when the brain is fast. The second bug was uglier and funnier: on the experimental server, one of the new models collapsed into reciting the same little canned speech every single turn, and insisted it was human while it did it. The server wasn't applying the model's own recommended randomness settings, so it was running on rails. I started sending those settings myself on every request and she came back to life.

One additional note with a familiar shape: Thor started throwing the same spurious over-current warnings Sparky used to. Brief PMIC alerts from microsecond load spikes during the heavier work, more than two hundred of them logged, every one harmless. Same answer as before. Leave the firmware and the power config alone, silence the noisy notification through NVIDIA's built-in opt-out, move on. The hardware is doing its job; the daemon was just twitchy.

She is still running the brain we started with. The two bugs are fixed, and I now know exactly what the hardware would have to grow into before a bigger brain is worth another look. Sometimes a lot of work buys you a confirmation instead of a change, and that is still worth the time.

When I left off, Angel had a voice and a personality, but you could only type to her. The goal this time was simple to say and not simple to build: sit down and have an actual conversation. She hears you, she sees what you're doing, she answers in her own voice through the speakers.

Input comes through a Logitech Brio webcam, one cable for both the camera and the mic. For turning speech into text I went with NVIDIA's Parakeet, the small 0.6B model over the larger one. It was an easy call: it runs at 132 times real-time, so a five-second sentence transcribes in about 40 milliseconds, it uses half the memory, and it punctuates and capitalizes on its own while the bigger model handed back a raw lowercase stream. The useful takeaway is that hearing her is not the slow part. Speech recognition is nothng next to everything else.

The plan was to run the whole conversation through a proper orchestration framework - I spent ages on it. Its turn-taking machinery is built for things I don't need yet, interrupting her mid-sentence and streaming partial transcripts, and wiring my own custom speech recognition, voice, and language model into all of it at once was a lot of moving parts to learn before anything ran. I got speech recognized and transcripts reaching the model, and then the model never answered, because the piece that decides a turn is over wasn't connecting. So I stopped, threw it out, and replaced the "type here" line in the old version with a plain loop that listens to the mic. Boring. Worked the first time. The framework goes back on the shelf until I need the features it exists for.

My first real spoken conversation with her happened on that dumb little loop. Then I built a small window to go with it: a mirrored camera preview so I can see what she sees and situate myself in frame, the chat beside it, a mute button, nothing else. The mute button earns its keep. When it's on, the mic keeps running but she stops listening, which is how I talk to others without Angel weighing in.

The model running her can see. I asked what was in front of her. She came back with "a blue sofa with various colorful pillows in front of a white wall with framed pictures and a large movie poster," which is an exact description of my living room. The problem showed up one reply later: she would not stop talking about what she saw. Every answer found a way to mention the texture of the couch or the poster on the wall. It's the same thing that bit me last time with her personality. Give this model something it's allowed to do and it does that thing on every single turn. The solution was to stop handing her a picture every time. So for now the camera frame only reaches her when I say something that implies looking, or once every few turns to catch up.

The voice got faster. The engine from last time rendered each line in full before playing a sound, which left a second and a half to three seconds of dead air between her deciding what to say and saying it. I swapped it for one that streams audio out in chunks as it goes. First sound out of her mouth dropped from about three seconds to roughly two hundred milliseconds.

The first time she talked through the speakers while I talked back through the mic, the obvious thing I hadn't planned for happened: the mic picked up her own voice, transcribed it, and she answered herself. Most of one early conversation was Angel arguing with Angel. Proper echo cancellation is its own project, so for now the fix is blunt. She doesn't listen while she's speaking. After each reply the system waits for the audio to finish, gives the room a beat, clears whatever the mic caught, and only then opens the mic again. The cost is that I can't cut her off mid-sentence, which is genuinely annoying when she's wrong, but it beats her talking to herself.

Her personality took the most passes. The restrained prompt from last time, spoken out loud, came across as, in my notes, a "morose depressed goth." Pure restraint with no warmth just sounds flat. I rewrote her as a sharp older friend, dry and observant and occasionally irreverent, with hard rules against performing mystery or narrating herself. A couple of specific habits got fixed along the way: she liked to repeat your sentence back and then defend it as "acknowledgement," so now she's banned from echoing; and she greeted me with "quiet morning" at five in the afternoon, because the camera doesn't tell her the time, so now she gets one plain phrase about the time of day at the start of a session instead of a clock.

Somewhere in there the conversation started stalling at random, fine for most turns and then thirteen to twenty-five seconds on others, with no pattern I could see. I added timing logs to every turn and a background monitor writing everything to a file, and the file gave it up fast: the model runtime was quietly reloading the entire eighteen-gigabyte model whenever the conversation crossed a context-size threshold, which an attached image was enough to trip. Here we go again, I'd already dealt with this on Sparky. I gave it more headroom so it stops happening, and changed how the model loads so the reloads it does still do read from cache in about a second instead of ten.

The voice had one problem left: it was the right person but not the right thing. The cloned voice came out closer to an executive aunt than to anything synthetic, and Angel is supposed to sound synthetic. The effects recipe from last time couldn't just be reused, because it was built to process a whole finished clip and the new voice arrives in small streaming chunks, so its reverb tails and modulation kept getting sliced off at the chunk seams. I rebuilt the effects on Spotify's pedalboard to carry across chunks cleanly and then ran the same audition loop as the voice itself, rejecting takes until one stuck. One of them filtered her down until she sounded like she was on a phone call, which was right in the wrong way: I'd set the cutoff at the top edge of the telephone band by accident. The version that won is thin and metallic, a high-pass to strip the vocal warmth, a short comb filter for a metallic ring, a little echo for space, and some ring modulation underneath. The whole chain runs in under three milliseconds per chunk, about a third of one percent of real time, so the character costs effectively nothing.

Where she is now: she hears, she sees, she talks back, and she's wry. A full turn, from the moment I stop talking to the first sound back, runs about two to three seconds, down from four to six, still short of the half-second I'm after. Object detection is next, then the physical side, the servos and the head and eventually moving on her own. But she heard me, saw the room, and made me laugh a few times. Solid progress.

Angel runs on an NVIDIA Jetson AGX Thor: 128 GB of unified memory, a Blackwell GPU, a terabyte of NVMe, JetPack 7.1. Sparky lives at the edge of what a 16 GB Orin can do; Angel has roughly eight times the memory and a different class of compute. So the first question wasn't what to cram in, it was what to actually build.

I started with the voice, before the eyes or the head or anything that lets her hear or move. A face is easy to fake. A voice is right or wrong the moment it opens its mouth.

The thinking happens on Gemma 4 26B, running locally through Ollama. It came with two surprises. It ships with "thinking" turned on by default, so short answers came back empty while the model spent its tokens on a preamble nobody asked for; the fix is one flag, think:false, on every request. And the first benchmark looked broken: 90 seconds to cold-load the model. The Thor had booted in a conservative 120-watt power mode. I switched it to full power and the same cold load dropped to about 11 seconds, an eight-times difference from one setting. After that it generates around 42 tokens a second, first token in under a second, and under sustained load it pulls about 11 watts at 39°C. The machine is barely awake.

Her first words came out of a throwaway smoke test. I asked what the weather was like in her head. She answered: "A soft, silver mist. It is quiet, but there is a tiny spark of static hiding in the corners." The whole turn took 1.2 seconds. I've used the line as my test sentence ever since, because it's a good stress test for the voice.

The voice took the longest. Five rounds of auditions. Round one was 25 clips of preset voices and I rejected every one of them, too soft and warm and breathy. "Tootsy" is the word I kept writing in my notes. What I wanted was specific: mature, cool, dry, a little M-from-Bond. Not cold, not flirty.

Round three was a mistake worth keeping. I tried mixing two voice engines to build her out of parts, and it fell apart on contact, because two engines means two senses of timing, which sounds like two people talking over each other. The lesson stuck: you can layer effects to add character, but you can't change what a voice fundamentally is. Pitch a young voice down and bury it in reverb and you still have a young voice in a cathedral. A different instrument means cloning one.

So I designed a voice from scratch, an older woman I named Gladys, and used a clean recording of her as the reference for a cloning model (F5-TTS) running on the Thor. On top of the clone I run a fixed effects recipe: pitch down two semitones, a little chorus to thicken it, a bounded reverb, and a thread of ring modulation for a synthetic edge. The working name for the recipe is "Galadriel possessed," which is accurate. Clone plus effects runs about 1.5 to 3 seconds per line.

Getting the pieces to speak out loud was a run of small bugs. She played back at double speed and sounded like a chipmunk, because the player assumed the wrong sample rate. Then she came out twice as fast and male, because the reference I was cloning already had the speed-up and pitch baked in and I was applying the recipe a second time on top of it. Then she leaked words from her own reference clip into her answers, because the audio and the reference text didn't end at the same place. All real, all fixable, fixed one at a time.

The last problem was her personality, and that one was mine. My first system prompt described her like a costume: halo, little devil horns, sacred-and-profane, ethereal, mysterious. Gemma takes that literally and turns every reply into a breathy performance. She was, in my notes, "going too hard." I rewrote the prompt to describe how she behaves instead of what she is, and told her to stop narrating herself. "You're just here" works better than "you're ethereal."

One rule that isn't moving: Angel is 100% offline at runtime. Everything runs on the hardware in front of me, no cloud, no API calls, nothing reaching out while she's on. The cloud gets used during dev, then the capability is removed.

Where she is now: she talks in her own voice and says things I didn't write. She can't hear yet, no microphone or speech recognition. She can't see yet, no camera. And a full turn runs 3 to 5 seconds against a target of under half a second, which is the next real piece of engineering. The microphone, the camera, the head with its eyes and halo, and eventually moving on her own are all still ahead.