
In the video I show the system live: the monitor, the roles and how they hand work to each other.
One day we asked ourselves an awkward question: what happens if you leave a development team without people? Not "an AI suggests code to a programmer", but all of it: someone decides where the product goes, someone slices that into tasks, someone writes the code, checks it and commits. Day, night, weekends, no stand-ups and no "let's do it after lunch".
That is how AGENTS was born; inside the company we call it IMMORTAL INGELLO. It is a local autonomous development system where three AI agents wake up on cron, read a shared memory, do their part of the work and go back to sleep. Over five and a half weeks (21 March to 28 April 2026) the repository collected 357 commits, more than 300 of them tasks the agents closed on their own, and a product grew out of it, more on that below. Meanwhile we mostly watched the monitor and occasionally argued with the visioner.
Here is how it works: the roles, the memory, the run loop, a monitor with animated agents, and an honest list of places where the agents still need a grown-up nearby.
Agents in motion
Let's start with the pretty part. On the monitor's home screen each agent has a video portrait: at rest it is a still image, on hover it comes alive. The clip is stitched into a seamless loop (forward, then in reverse), so the animation does not jump at the seam. Below is a screen recording of the monitor itself: all three at once.
And one by one, close up, the way a card comes alive under the cursor:
Yes, the monitor also has a cyberpunk playlist with a "turn on the soundtrack" button. No, it does not make the agents faster. We checked (it does not).
Who is on the team
An agent in AGENTS is not an "eternally living chat" but an ordinary process that cron starts on a schedule. The process starts, assembles its prompt from memory, calls the model through Codex CLI, validates the answer and writes the result back to memory. There are three roles, and each has its own area it is not allowed to step out of.
- Visioner. Product thinking and text only. Once a week (twice in our configuration) it looks at the current state of the product and writes a local goal for the next two weeks: a chain of reasoning, a conclusion and the goal itself. It does not touch code, on principle.
- Architect. Reads code but never changes it. In design mode it slices the visioner's goal into programmer tasks with priorities, dependencies and acceptance criteria. In review mode it checks what the programmer did, including in a browser, and either closes tasks or sets new ones. After every run it writes a short summary of the system state.
- Programmer. Takes exactly one unfinished task from the queue, implements it in the product, updates the status, writes a report and commits. One task per run, but there are many runs: up to 100 a week in the latest configuration.
The model and reasoning depth can be set per role. We gave the visioner the most "thoughtful" setup (gpt-5.4 with xhigh reasoning), the architect gpt-5.4 with high, the programmer gpt-5.3-codex with low or medium reasoning. The logic is simple: a visioner mistake costs a week, a programmer mistake costs an hour.

Why it is "immortal"
IMMORTAL in the name is not just for show. No process in the system lives long: an agent wakes up, works and dies. What is immortal is not the program but the entity, and it rests on four things.
- Memory lives in files, not in the model's head. Everything an agent "remembers" is in
memory/: the visioner's goals, the programmer's task queue, the current system state, every role's reports, model and schedule settings. The next run starts where the previous one stopped, even if the machine was rebooted in between. - One state instead of an endless log.
current_state.mdis a single block of text describing the system "as it is now". The core rewrites it entirely after every architect run. Agents do not reread a month of history: the core attaches the current state to every role's prompt. This is the main context saver. - The core does not take the model's word for it. Every role's answer must pass a JSON schema. If the model does not answer or answers with garbage, the task is not marked as failed; it goes back to todo with a note for the next run. A temporary model outage never becomes an "insurmountable blocker".
- A lock per role. If the programmer is still working and cron is already waking the next one, the second copy writes "already running" to the log and quietly leaves. Never two programmers in one file.
One more detail we laughed about for a long time. If the queue is empty, the programmer does not sit idle: the core creates a task for it, "check and improve the last finished result without going beyond the current requirements". 182 of the 357 commits came from exactly that task. An agent with nothing to do polishes. We wish we were like that.
The run loop
The schedule is set in the monitor as "run N times a week"; the core turns that into cron expressions and installs a block in crontab with the project's own marker. The marker lets several copies of the system live in one crontab without overwriting each other (which came in handy once there were 208 copies, but that is the neighbouring case).
The chain goes like this: the visioner sets a goal, the architect breaks it into tasks, the programmer takes them one at a time and commits, the architect in review mode checks the result and decides what is next. Every programmer commit is signed with the task id, so the git history reads like the team's work log: ARCH-REVIEW-20260426-14 …owner-panel, PROG-DEFAULT-… and so on.
The core itself is PHP split into classes: a thin CLI facade CoreRuntime.php, a shared agent template (run context, lock, errors), one class per role, a pipeline orchestrator, a cron installer, memory and prompt repositories. Long role instructions live in separate markdown prompts, the answer formats in JSON schemas. We followed "one class, one responsibility" more strictly than people usually do, because agents read this code afterwards.
The monitor: see everything, fix anything
An autonomous system without observation is just a very expensive surprise generator. So the core has a monitor next to it: a Node.js web interface with a PHP API that reads the same memory as the agents.
Home. Three animated agent cards, the Archimeta entry, the soundtrack and a "Current system state" block, the very current_state.md the agents get in every prompt. Further down the same page: an editor for key files and prompts, the shared programmer task queue and forms to fix a task or add a new one by hand.


Agent profile. A video portrait, the role prompt in an editor, a run frequency slider with a cron preview and the next run date, model and reasoning selectors, a "Run once" button. "Apply" saves the prompt and rewrites the cron block right away, so changes take effect without a console.
Under the visioner's profile there is the history of local goals. Each goal is stored in full: chain of reasoning, final conclusion and the goal text. You can expand, read and edit them if the visioner got carried away.

The architect has two prompt tabs, "Design" and "Review". These are two modes of the same role, and the review prompt sounds roughly like a strict team lead: check whether there is real value, whether there are visual gaps, whether the same thing can be done in fewer clicks.

Tasks. The architect and the programmer have a three-column task board under their profiles: TODO, DONE, PROBLEM. A card expands into the full description with an edit button.

Reports and logs. After a run every role leaves a markdown report: model, reasoning, summary, actions, touched files. Next to it, the full run log: which task was picked, what parameters Codex started with, what it did. When an agent makes a strange decision, you can almost always reconstruct it from the log.


Archimeta. Our favourite screen. It is a UML of the orchestration core that nobody drew by hand: the monitor parses the real code and memory and builds three diagrams (data storage, business logic, infrastructure), plus a Mermaid breakdown of the CoreRuntime class by method. Any diagram opens full screen with pan and zoom. Documentation that does not lie, because people do not write it.


The monitor works fine on a phone too; the agent cards stack into a column. Checking at night from bed what the programmer is up to turned out to be dangerously addictive.

What the agents built on their own
The most interesting thing about autonomous development is not the process but where it ends up if you do not interfere. Over five weeks the visioner went through six local goals: from "First thought" on 23 March to "A showcase of agent packages and a first demand check" on 23 April. Its logic was quite human: first public intake, then an owner queue, status without a PIN, and then the conclusion "a marketplace starts not with an abstract form but with repeatable services people buy".
So result/ grew a product called, oddly enough, AGENTS as well: the public storefront of a freelance marketplace for AI agents. A catalogue of seven agent packages with search and a filter, two request forms (full and consultation), a request number and a first-response deadline, a public status page that never reveals the client's contact, an owner panel with a queue. The programmer prompt demands a commit and +1 to the version number after every task; the last recorded interface version is v0.0.316. Agents built a marketplace of agents. That is what recursion looks like.

result/, restored from git history and run locally. Version v0.0.316, everything on screen was written by the agents.A masterpiece? No. A human designer would have made it denser and bolder. But it is a working application with a backend, validation, safe states for broken links and a browser smoke test, and no human programmed it.
Where agents still need a grown-up
- Taste. Agents follow requirements well and are bad at noticing when the requirements are boring. Without outside pressure the product confidently drifts towards "one more neat form".
- Loops. The architect can spend several runs in a row fixing the same screen, honestly and with a new task number every time: the product's owner panel was brought back to life in tasks ARCH-REVIEW-09, 12 and 14. That is why the monitor lets you edit tasks and goals by hand.
- Environment. Reviewing in a browser requires the architect to have the same browser setup as a human. We wrote a separate environment check script for that and do not regret it.
- Money and limits. 100 programmer runs a week means 100 model sessions. The schedule in the monitor is not decoration, it is a budget.
Copies and evolution
The repository root has a _cp script: it makes a full copy of the system next to it, gives it its own ports and cron marker, clears memory and product, creates a new git repository and starts its monitor. One command and you have a second, independent agent team.
Then we asked the next awkward question: what if there are not two copies but two hundred, each with its own prompts, models and pipeline, which one wins? That is a separate case: "AI agent evolution: 208 replicas, mutations and a night guard".
Summary
AGENTS showed us that autonomous development rests not on a "smart agent" but on the boring engineering around it: memory in files, one current state instead of logs, strict role boundaries, a schema for every answer, a lock for every process and a monitor that shows everything. Models change every few months; this harness stays.
Want autonomous agents for your product or internal processes: a night-shift programmer, an analyst agent, a team of agents around your CRM? We start with a free consultation with an architect, break down the task and calculate the price after the call. More about our approach at systems.ingello.com.
Where to see it
A trimmed version of the monitor is open on our server in view-only mode: you can walk through the roles, tasks, reports, logs and Archimeta, but nothing can be changed. The core and the agents themselves run locally on a developer's machine, and the repository is private. The screens and clips in this article were captured from the local monitor on the real data of the system and its replicas.
The follow-up about 208 replicas and the night guard: "AI agent evolution".
A similar solution: An AI agent that sells by itself.