Project OS

The problem

I had built several useful agents and connected them to different parts of my life, but I was still the routing layer between them. I used Codex on my Mac, connected to my Notion and local filesystem, occasionally used Claude on the cloud, and I had OpenClaw agents running on a server, each responsible for a different area of my life. This sprawl led to a different version of "Julio's career" or "Julio's health" in each. Every task began with me deciding which tool to use, reconstructing the relevant context, explaining what it could do, and remembering where the work had stopped. The agents were capable; the surrounding system for assigning, observing, and reviewing their work was not.

The approach

I started by consolidating durable context into a personal wiki and filesystem, following Karpathy's LLM Wiki idea. I then made Codex the runtime for both conversations and automations, using Jeeves (my favorite agent) as the single user-facing identity, and demoted the remaining specialist agents as workers it could call. I then used Linear as the state machine for the work itself. Each task records the outcome, scope, exclusions, minimum context, automation level, authority, next actor, and definition of success before it can enter the pipeline.

How it works

A planning skill on Codex turns an informal intention into a reviewable task contract. Once approved, a scheduled dispatcher (every 30 mins) looks for tasks whose next actor is the agent, claims a stable task revision, and starts the appropriate Codex work. Fully automatable tasks may complete within their explicit authority, such as canceling a subscription end-to-end. Partially automatable work returns to In Review stage with evidence, a record of what was not done, and the exact decision or action required from me. Specialist workers can contribute behind Jeeves, while the task remains the shared source of state.

Key decisions

• Use one user-facing agent and keep specialist capabilities behind it, so I no longer need to remember which agent owns each job.
• Make the task tracker the observable state machine instead of relying on an agent's memory or a long-running conversation.
• Separate automation level from authority: a task may be highly automatable while purchases, messages, bookings, and destructive actions still require review.
• Retrieve the minimum context required for each task rather than exposing the entire personal knowledge base to every run.
• Treat human review as part of the workflow, with explicit handoffs and a mobile approval path, rather than as an exception when automation fails.

Current use

I'm using this personal operating system daily. It has helped have one source of the truth and get more from my AI by creating one interface I'd interact with it. A small chat with Jeeves on Codex takes an intention to a Linear ticket that soon becomes a useful first version without requiring me to route every step, while bringing decisions, credentials, identity checks, purchases, and physical actions back to me. Most tasks are still only partially automatable, so there is one clear bottleneck: my attention. The In Review queue is where most tickets are sitting right now.

What I’ve learned

The hard part was not giving an agent more autonomy. It was making context, authority, state, and handoffs explicit enough that work could progress safely and remain observable. A capable agent can still leave work stranded if the dispatcher creates duplicate runs, the result is not attached to the task, or the next actor is unclear. I also learned that one front door is a user-experience goal rather than a literal architecture: narrow workers, approval services, and delivery channels can remain behind it as long as I do not have to orchestrate them myself.