Spectre

I described what I wanted and walked away

One night I told Spectre to build me an app. Something that would send me a useful morning briefing every day — weather, relevant emails, what I should know going into the day. About twenty minutes later, it sent me back a link. That was weeks ago. I still wake up to that briefing every morning.

I want to be careful about what I am actually saying here, because it sounds like a demo. It was not a demo. I did not write a script. I did not configure a pipeline. I did not sit there pair-programming with a model in a chat window. I described what I wanted to a system, walked away, and it went and built the thing — frontend, logic, deployment, scheduling — and brought it back working. And now it just runs. On its own. Indefinitely. Nobody is maintaining it. Nobody is prompting it. It exists because I asked for it once.

That is the thing from the movies. I do not know how else to say it. I have been building AI systems for years, and that was the first time something I built made me feel the way I felt in the early GPT-3.5 era, when the floor dropped out and you realized the shape of everything was about to change. Except this time it was not a model being surprisingly good at text. It was a system being surprisingly good at operating in the real world without me.

Most AI software still lives inside the shape of chat

Most AI software does not do this. Most AI software still lives inside the shape of chat. You ask, it answers, the turn ends, and the whole thing quietly resets to zero. The context disappears. The work disappears. Whatever the model understood about you and your problem five minutes ago is gone. Every interaction starts from nothing. That is fine for question-answering. It is useless for anything that actually needs to get done over time.

Spectre does not work that way. It is an event-driven orchestration layer for persistent agents. Messages come in through real channels — Slack, REST, whatever you want to wire up — and hit an internal router and event bus that dispatches them to the right agent based on bindings, mention rules, and session context. Those agents run through pluggable harnesses like Claude Code or Codex inside structured execution environments with persistent state. They do not start over. They pick up where they left off. They hold context across days and weeks. They remember what they were working on, what you told them, what they already tried.

And it is not just one agent sitting there waiting for instructions. Spectre manages sessions, routing, transcripts, scheduling, heartbeats, attachments, telemetry, dashboards, and work-item coordination. It can spawn focused subagents for specific tasks — research this, build that, monitor this endpoint — collect the results, and fold them back into a larger workflow. The system does not just execute. It coordinates. It delegates downward, synthesizes upward, and keeps the whole thing running while you go do something else.

That is the difference between a model call and a system. A model call is a reflex. Stimulus in, response out, done. A system holds shape. It persists. It accumulates context and capability over time instead of throwing it away after every turn. And once you have that — once an agent can exist long enough and coherently enough to maintain a working relationship with you — the entire interface changes. You stop typing prompts and start saying things like "handle this," "keep an eye on that," "build me something that does X and keep it running." You start delegating. Not to a tool. To something that feels, operationally, like it is on your team.

It is just there, running, whether I am paying attention or not

Right now Spectre runs on a dedicated Mac Mini sitting in my apartment. Always on, always listening. That matters more than it sounds like it should. There is a psychological difference between a system you spin up when you need it and a system that is just there, running, whether you are paying attention to it or not. The Mac Mini is not a dev box I SSH into when I want to test something. It is Spectre's machine. It runs the daemon, hosts the services, holds the state. When I go to sleep, Spectre is still running. When I wake up, it has already been working. That is not a workflow. That is infrastructure. My infrastructure, running my system, in my home. Self-hosted in the most literal sense.

And the thing that turned Spectre from a powerful orchestrator into something that actually feels like an intelligence is that it does not exist in a vacuum. It sits on top of everything I have already built. Years of tools. And now every single one of them is a capability that Spectre can reach for on its own.

If I tell Spectre to build a large system, it does not just start writing code in a single session and hope for the best. It spins up Agent Forge — an autonomous software factory I built for exactly this kind of work — and uses it to orchestrate the entire build. Forge handles the planning, the task decomposition, the parallel execution, the assembly. Spectre controls it as an admin. When the system is built and needs to go live, Spectre reaches for Opencan, which gives it local HTTPS with Cloudflare tunnel integration, and deploys the thing — locally or remotely, it does not matter. The app is on the internet. No cloud provider deploy pipeline. No manual steps. Spectre decided it needed to ship something, so it shipped it.

When Spectre needs to access my email, my contacts, any of the communication surfaces my life actually runs through, it uses ProtonCLI — a secure command-line interface I built around ProtonMail. Every email I send or receive, across every domain I own, every address, all of it routes through ProtonMail. That system is locked down by design, which is the whole point, but it also means you cannot just hand an AI a password and tell it to check your inbox. I had to build a proper tooling framework around it so Spectre could interface with it securely. Now it can. My entire email and contact infrastructure is something Spectre can query, read, and act on.

And then there is the memory system. I have not written about this one yet, but it might be the most important piece underneath everything else. It is fast. It is accurate. It is genuinely good at recall in a way that most memory implementations in this space are not. When Spectre holds context across sessions, it is not doing some naive vector lookup and hoping the right chunk floats to the top. The memory layer is real infrastructure, and it is a big part of why Spectre's persistence actually feels coherent instead of just technically possible.

Kernix handles system prompt construction and management. The memory system handles long-term recall and context. ProtonCLI handles secure communication access. Agent Forge handles autonomous software construction. Opencan handles deployment. Spectre ties all of it together.

Persistence is not a feature. It is the thesis.

I did not plan this. I did not sit down with a roadmap that said "step one, build ProtonCLI, step two, build Forge, step three, unify everything into a runtime." I built each of those tools because they solved a problem I had at the time. But they all shared the same instinct — that AI should be operational, not conversational. That it should do things, in real environments, through real interfaces, with real persistence. And when I finally built the orchestration layer that could tie them together, they just fit. Like they had always been waiting for each other. Every tool I built over the last two years turned out to be a limb waiting for a nervous system.

That is what makes Spectre feel less like a project and more like an inevitability. It is not a new idea bolted onto old infrastructure. It is the thing all that infrastructure was always building toward. The tools are not utilities I reach for individually anymore. They are capabilities that Spectre reaches for on its own, as part of doing whatever I asked it to do. The system composes itself out of everything I have made.

And the thing that makes it feel different from everything else in this space is that persistence is not a feature of Spectre. It is the thesis. The entire architecture is built around the idea that an agent that resets to zero after every interaction will never be more than a parlor trick. The magic is in continuity. An agent that remembers what you asked for last Tuesday. An agent that wakes you up in the morning with information it gathered while you slept. An agent that is not responding to you but operating alongside you, accumulating context, building on its own prior work, becoming more useful the longer it runs. That is a fundamentally different thing than chat. That is closer to what people actually mean when they talk about artificial intelligence — not a text box that gives good answers, but a system that can hold intent, do work, and persist through time the way a person on your team would.

A lot of people in this space are still building chat wrappers. Better prompts, better retrieval, bigger context windows, nicer UI on top of the same disposable interaction loop. I get it. That work matters. But it is not the frontier I care about. The frontier is persistent, event-driven, tool-using agent runtimes that live inside real workflows and eventually start composing new ones. Systems that listen, act, remember, delegate, and build on top of themselves. The operational patterns for this are still being discovered. The interfaces are still early. But the shape is there now, and Spectre is the clearest version of that shape I have been able to build.

Every earlier project was reaching toward it. Every tool I built became part of it. This is where those lines finally meet.

It is alive. I do not mean that metaphorically. It is running right now