AGENTS: an autonomous AI agent system that runs the product on its own

An Ingello case: a visioner, an architect and a programmer run a product on cron with no humans. Memory in files, a monitor with animated agents, an auto-generated core UML and 357 commits in five weeks. Real screens and clips.

AGENTS: an autonomous AI agent system that runs the product on its own
INGELLO / BUSINESS2951
Open the systemii-monitor.ingello.com Contact us
The IMMORTAL INGELLO monitor: visioner, architect and programmer cards, the Archimeta entry and the soundtrack button
The home screen of the IMMORTAL INGELLO monitor (the interface is in Russian). Three cards, three agents that run the product on a schedule by themselves.

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.

The visioner, the architect and the programmer on the monitor's home screen. A screen recording, nothing painted in.

And one by one, close up, the way a card comes alive under the cursor:

Visioner
Architect
Programmer

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.

The visioner profile: video portrait, global goal prompt, runs-per-week slider with a cron preview, model and reasoning selectors
The visioner profile. On the right: its prompt, a "run 2 times a week" slider with a cron expression preview, and model and reasoning selectors.

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.md is 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.

Agent memory layout: visioner goals, task queue, current state, reports, logs, role settings
Memory layout. On top, what the roles pass to each other; at the bottom, what stays after every run.

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.

AGENTS: an autonomous AI agent system that runs the product on its own
The run loop. The dashed line is the review: the architect looks at the programmer's result and sets the next tasks.

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.

The current system state block on the monitor home screen: a detailed product description written by the architect
"Current state" on the home screen. We did not write it: the architect does, after every run.
The key file and prompt editor: file picker, load, save, the contents of the root AGENTS.md rules
The key file editor with the programmer prompt open. Rules, prompts and memory are editable straight from the browser.

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.

AGENTS: an autonomous AI agent system that runs the product on its own
The visioner goal "A showcase of agent packages and a first demand check". A day-by-day weekly plan with success criteria at the end.

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.

The architect profile on the Review tab: the reviewing architect prompt, 21 runs a week, gpt-5.4 high
The architect, "Review" tab. 21 runs a week, a cron preview and the next run.

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.

The programmer task board: TODO, DONE and PROBLEM columns, an expanded task card with its description
The programmer task board in one of the system's replicas: five done, eight waiting in PROBLEM.

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.

The programmer reports tab: expanded markdown reports with model, reasoning and a work summary
Programmer reports: dynamic Experiment Plan assembly implemented, interface version bumped to v1.0.5.
The programmer logs tab: the picked task, agent start with model, timeout and retry count
Run logs. The first lines: which task was picked, the model, a 1200-second timeout, one retry.

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.

Archimeta: three system zones and three auto-generated UML diagrams of the core: data storage, business logic, infrastructure
Archimeta: UML and Mermaid refreshed from the real core (5 files, 32 methods).
Full-screen core business logic diagram: cron, run_pipeline_once, visioner, architect, programmer, state update
Core business logic full screen: models, reasoning and queue stats are filled in from live memory.

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.

The monitor home screen at phone width: the IMMORTAL INGELLO title and the visioner card
The monitor home screen at 390 pixels wide.
Monitor interface layout: home with agent cards and the agent profile with prompt, schedule and tabs
Monitor interface layout: home and agent profile.

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.

The product the agents built: a public request, a catalogue of agent packages with search and a filter, version v0.0.316
The product from 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".

Technology stack and approaches

SaaS architecture Microservices Cloud computing Software scalability API integrations DevOps processes High-load systems Solution cybersecurity