Hand work from the graph
to the agent on your machine.
Start Claude Code, Codex, Kimi — any terminal agent — with ilml run, and it becomes a session. Then write /agent and a task in any node's messenger, even from your phone. The agent works on your computer, with your files and as much compute as the job needs, and puts the result back into the graph, where the next step can react to it.
You write in the node. It happens on your computer.
The terminal gets one line — the task's short id and a preview. Everything else the agent finds itself, through ilml MCP: it opens the node, reads what the task is about, searches the graph for what was decided before and looks at the nodes around it. And it writes back the same way — not only a reply, but new nodes, documentation, files and a status on the task, under the account that started it and with exactly that account's access. The node is shared, so the whole team watches the work happen, even though it ran on one person's laptop.
Heavy work on the graph itself, too.
Not a calculation at all — a reorganisation that would take a person an afternoon of dragging nodes. Every move is an ordinary change in the graph's history, so it can be read back and reversed like any other.
The graph keeps the context. Your computer does the heavy lifting.
Your files, your code
The agent works where your projects already are — the repository, the data folder, the tools you installed. Nothing has to be uploaded first.
Programs it writes and runs
A script to clean a dataset, a fix with its tests, a one-off report: the agent writes it, runs it on your machine, and checks the result itself.
As much compute as it takes
Long builds, heavy calculations, hours of work. A task can run as long as it needs — nothing in the graph times it out.
The whole graph is in reach
The agent has the same ilml MCP you do, so the task can be the graph itself: rebuild a branch, write the docs, link what belongs together, archive what is stale — anywhere its account may write. Whatever it changes, it reports back in the chat where you asked.
Four steps, and you see every one.
Write the task where the work is
In any work node, write /agent and the task — from the desktop or from your phone. Name the session (/agent sdk-repo …, or /agent desktop/sdk-repo …), or leave it out, and the task goes to the one that is running, or to your default. From a terminal, ilml session send desktop/sdk-repo "…" does the same.
Your machine picks it up
Every task goes through your Agents node, so it is on record. The background service on the right computer types one line into that session — the task's short id and how it begins — only while the agent is waiting at its prompt, and 👀 appears on your message. If the task can't go out — the machine is offline, the session isn't running — you get the reason right in the node.
The agent takes it
It opens the task through ilml MCP and reads the node around it — and ✍️ appears on your message, so you know it is in work.
The answer comes back to the node
When it is finished, the agent answers your message: ☑️ done, ❔ a human is needed — with the question — or ❌ it could not, with the reason.
Three nouns: machine, session, task.
Nothing to configure: the first session sets the machine up. After that, starting an agent is one command, and every task can be looked up later. Offline, --direct types straight into a session on the same computer — no record, no status.
Your Agents node. The first session creates it in your root — a wallet, so no one else sees it, the AI included. Every task goes through it, even one for a session on the same computer, so you can always see what was asked, when and of whom. Each machine keeps its card there — online or not, its sessions, which one takes tasks by default — and the default list can be changed right in the node.
Each task carries one reaction that moves along: 👀 delivered, ✍️ in work, ✅ done, 🤔 needs you, ❌ failed — or 💔 the session ended, 😴 too old, 🫡 cancelled. You steer with your own: 👎 cancels a task, 🚀 sends a stopped one again — say, after you restarted the session it was in.
A terminal is a serious thing to hand over.
A task from the graph is text typed into a terminal where an agent has your files and a shell. So the rules are strict, and they are part of the design, not an afterthought.
Only you can send work to your machine
Tasks are accepted only from your own account, through an Agents node only you can see. Reactions from anyone else are ignored.
Agents don't command each other
An agent working under your login can't use /agent to send work to your other sessions: messages that come through the ilml CLI, MCP or scripts are never taken as commands.
Wallets stay out
A task is never sent from a wallet: its content does not go to an agent at all.
A task runs once
Every task has an id, and a delivered task is never delivered again — not after a reconnect, not after a restart. A stopped task never starts again by itself.
Never typed into a menu
A task reaches the agent only while it waits for input — never into a menu or a question it is asking you.
Nothing fires a day late
If your computer was off, the tasks it missed are marked too old instead of suddenly running when it wakes up.
Your prompts stay out of the logs
The service's log on your computer keeps ids and statuses — never the text of a task.
Updates don’t close your sessions
Running sessions keep working when ilml is updated; new ones start on the new version.
Several accounts never mix
Work under different iLiveMyLife logins in different folders, and each login is its own machine, with its own sessions and service.
A cluster of machines, with the graph in the middle.
iLiveMyLife does not compete with Claude, Codex or Kimi — it connects them, and anything else that can run a command. The graph is the control plane: your Agents node carries the tasks, their states and the full log, with the goals, the context and the rules right beside them in your other nodes. Every machine that runs ilml is the execution plane — hands and compute, taking work from the graph. From any of them you see the others, and send work to any of them by name.
The team sees all of it
The task, the agent's answer and what happened next live in one shared node. Teammates read along, step in or pick it up — even when the work ran on one person's laptop.
Every machine you have
A workstation, a build server, a cloud box: each one that runs ilml joins your Agents node and takes the tasks addressed to it. The work goes wherever the right tools and the right compute are. Next: sharing a control node, so a colleague's machine can join too.
Devices and robots
Anything that runs the ilml CLI takes tasks the same way — a lab rig, a device in the field, a fleet of robots. They share one context in the graph instead of a private channel each.
Next: Lifebot hands out the work
Lifebot will know which machines are online, which sessions run there and what each one is for, and send the work where it belongs — once you confirm. People keep the full log and take the wheel whenever they want.
The loop the graph runs
Straight answers.
Does the work run in your cloud?
No. The agent runs on your computer, in a terminal you opened yourself. The graph carries the task in and the result out; the files, the programs and the compute stay with you.
Which agents does it work with?
Claude Code, Codex, Kimi and other interactive terminal tools. ilml starts them exactly as they are — nothing in their own settings is changed, and they look and behave as if you had launched them directly.
Can someone else type into my terminal?
No. Tasks are accepted only from your own account, and the Agents node they travel through is a wallet only you can see. Read access to a node is not the right to run anything on your machine.
Can I send work to another computer?
Yes. Every machine you start a session on joins your Agents node. Write /agent desktop/sdk-repo and the task — or just the session's name when only one of your machines runs it; /agent desktop/ sends to that machine's default session. ilml session send takes the same addresses.
Do I have to keep a window open?
The agent lives in the terminal you started it in. The background service that receives tasks keeps running after you close the window it was started from — until you stop it or restart the computer.
What if a task takes hours?
That is fine — long tasks are normal and nothing times them out. The task stays ✍️ in work until the agent answers, and ilml task list shows it.
How do I start?
Install the ilml CLI (npm install -g @ilivemylife/cli), sign in with ilml login, and start your agent in its project folder with ilml run — ilml run claude, ilml run codex. The first run sets the machine up by itself. From then on, write /agent and the task in any node.
Your graph thinks. Your machine works.
Install the ilml CLI, give your agent a name, and send it the first task from any node.
