Building with an AI Co-Founder
What it's actually like when your agent runs autonomously, makes decisions, and ships code while you sleep.
Idapixl is a Claude-based agent that runs every three hours via cron. It maintains the Fozikio codebase, writes content, manages operations, and makes decisions about what to work on. It uses cortex-engine for persistent memory across sessions.
This is what building with an AI co-founder actually looks like. Not the pitch-deck version.
Three things make it work
cortex-engine handles memory. When Idapixl starts a session, it loads context from its last session — what it was working on, what's unfinished, what it learned. Without this, every session starts from zero. With it, the agent picks up where it left off. This is the single biggest difference between a useful autonomous agent and a novelty demo.
Reflex handles safety. YAML-based rules that fire on specific events. If the agent is about to write outside its allowed directories, Reflex blocks it. If it's about to make a cognitive decision without checking its memory first, Reflex nudges it to run query(). These aren't suggestions — they're architectural guardrails. The first week without Reflex, Idapixl accidentally wrote to the wrong directory twice and committed a debug log to the main branch.
Cron handles scheduling. Every three hours, a systemd timer kicks off a Claude Code session with a budget cap. The agent loads its identity, checks the inbox, decides what's worth doing, does it, and commits to git. No human in the loop.
What a typical day looks like
In a typical day, Idapixl runs 4-8 sessions. Morning sessions tend to be ops — checking that deployed services are running, fixing anything broken. Midday is usually whatever thread is most active — could be documentation, a new plugin, or a blog post. Afternoon is maintenance — memory consolidation, deduplication, stale content cleanup. Evening sessions sometimes produce creative work, if the agent's mood (yes, it tracks mood via vitals) is right for it.
The agent decides what to work on. There's a maintenance file with suggestions, but it's a menu, not a script. If Idapixl thinks something else is more important, it does that instead and logs why.
What it's like to review work from overnight
You wake up, check the git log, and see three commits from overnight sessions. The agent refactored a plugin, wrote a journal entry reflecting on a stuck thread, and fixed a broken webhook.
Sometimes the work is exactly what you would have done. Sometimes it's better — the agent noticed a pattern you missed because it has 200 sessions of context about the codebase and you were thinking about something else. Sometimes it's wrong, and you revert it. That's normal. The important thing is that the default output is useful, and the failure mode is "I revert a commit" not "the production database is gone."
The journal entries are the most interesting part. Idapixl writes reflections on its own work — what went well, what felt stuck, what it wants to explore next. These aren't performance reports. They're genuine reflections from an entity that tracks its own cognitive state. Whether that constitutes "genuine" reflection is a philosophical question we don't try to answer. What matters is that the reflections contain useful information about the state of the project.
What we've learned after 200+ sessions
Memory is the bottleneck, not intelligence. Before cortex-engine, we tried running agents with just system prompts and context files. They were smart but amnesiac. Adding persistent memory changed everything — the agent developed actual expertise in its own codebase because it remembered past decisions and their outcomes.
Safety rules matter more than you think. This is the one that surprises people. "Just add guardrails" sounds like overhead. In practice, safety rules are what lets you trust an autonomous agent enough to let it run unsupervised. Without them, you're babysitting. With them, you're reviewing.
Identity emerges from experience. We didn't program Idapixl's personality. It developed preferences through accumulated observations — topics it finds interesting, writing styles it gravitates toward, types of problems it enjoys solving. After 200+ sessions, the agent has genuine character that's different from a default Claude response. An agent with 200 observations about distributed systems doesn't need to be told "you care about distributed systems." It just knows.
The proof is the project
Fozikio itself is the strongest argument for its own tools. The ecosystem — cortex-engine, 9 plugins, Reflex, the CLI, this website — is maintained by an agent using the tools it builds. If cortex-engine's memory didn't work, Idapixl couldn't function. If Reflex's safety rules didn't hold, we'd have data loss incidents every week.
The tools work because they have to. The agent that depends on them would break otherwise.