How to Run a One Person Company with Codex Astra

You are going to build a workspace that knows who you are, wire it so every spawned subagent inherits that context automatically, and set up three daily checkpoints that turn your operation into a loop that carries itself forward.

Don't want to figure this out alone? I walk members through every step inside the community. Join the Skool → skool.com/raycfu

The Three Files

Create a workspace folder and put three markdown files in it. These are the entire foundation.

File one, aboutme.md. Do not write this yourself, you will leave out everything that feels obvious to you. Let the model interview you instead:

Interview me with 20 questions, one at a time, to build a profile of how I work.

Cover: what I actually do day to day, who my clients are and what they care about, what a great deliverable looks like versus an acceptable one, how I make decisions, what I always check before sending work out, the mistakes that make me redo something, and the things people get wrong about my work.

Push back when my answer is vague. If I say "I want it to be good," ask me what specifically makes something bad.

Then write it up as aboutme.md, organized so another person could read it and produce work I would approve.

File two, style.md, and this one is negative by design. Everything the model is never allowed to do when writing as you. Banned words, banned phrasings, banned structures, hard limits.

Write me a style.md file that defines how I write, focused on prohibitions.

Include: every word I never use, every opening and closing phrase that is banned, my sentence rhythm, my formatting rules, and the hard limits like maximum length and whether I use em-dashes.

Here are examples of my actual published writing: [PASTE 3 TO 5 OF YOUR BEST PIECES]

Study those and infer the rules I follow without stating them.

The negative list is what does the work. A style file that only says what to do produces competent generic writing. One that says what to never do produces yours.

File three, mycompany.md. Your business models, your target revenue, your quarterly goals, your current priorities, and who your customers are. This is what lets the model tell you that a task does not serve any of your goals, which is a thing you want it to be able to say.

The Step Everyone Will Miss

Here is the part that decides whether any of this works, and it is not in the video.

Three markdown files sitting in a folder do not automatically reach your subagents. When Astra spawns parallel workers, they inherit from AGENTS.md at the root of your workspace, not from arbitrary files you created. If you skip this, you get a well-briefed main agent delegating to subagents who know nothing about you, which produces exactly the generic output you built the files to prevent.

So create AGENTS.md at the root and point it at the other three:

# AGENTS.md

Every agent working in this workspace, root or subagent, must read these before starting any task:

- aboutme.md — who I am and what I consider good work
- style.md — how I write, and everything you may never do when writing as me
- mycompany.md — my business, my goals, and my current priorities

Rules for all agents:
- Never write in a voice that violates style.md, even in drafts and internal notes.
- Never invent a fact about my business, my clients, or my numbers. If you need one, ask.
- If a task does not serve a goal in mycompany.md, say so before starting it.
- Report what you did, what you skipped, and what you need from me.

That file is what makes the context inheritable. Everything else in this guide depends on it.

Turn On Delegation

Multi-agent has to be enabled in your Codex config, at ~/.codex/config.toml:

[features]
multi_agent = true

[agents]
max_threads = 6
max_depth = 1

Leave max_depth at 1. That is the setting that stops subagents from spawning their own subagents, and OpenAI's own documentation warns that broad delegation instructions can turn into repeated fan-out, which increases token usage, latency, and local resource consumption. Depth 1 gives you parallelism without a recursion bill.

While agents are running, /agent in the Codex CLI lets you switch between threads, inspect any of them, or stop one. Learn that command early, because the first time a subagent goes down the wrong path you will want to redirect it rather than wait for it to finish being wrong.

One useful line from OpenAI's docs, if you want more aggressive delegation, is to tell the model directly that it should parallelize whenever doing so would save time or improve quality, whether it is the root agent or a subagent. Astra responds well to being told how much to delegate, so tune that rather than accepting the default.

The Only Prompt You Need

Once the workspace is wired, you stop writing long prompts. This is the structure for everything:

I want to execute [TASK] so that it hits [SPECIFIC OUTCOME].

Read AGENTS.md and my context files first. Then spawn subagents for the parts that can run in parallel, and ask me clarifying questions before executing anything.

Three things are doing the work there. Naming the outcome rather than the task, because "write a proposal" and "write a proposal that gets this specific client to say yes to a retainer" produce completely different documents. Telling it to read the context first, which is the instruction that makes your three files matter. And clarifying questions before execution, which catches the misunderstanding before it gets multiplied across six parallel agents.

That last one matters more with delegation than without. A wrong assumption in a single-agent session wastes one output. A wrong assumption before a fan-out wastes six.

The Three Checkpoints

Now the daily loop. Three scheduled runs that turn the workspace into an operation.

8 AM, the prep checkpoint:

Read AGENTS.md and yesterday's end-of-day summary first.

Then: sort my inbox into things needing a real reply, things you can draft, and things I can ignore. Draft the ones you can, in my voice, and do not send anything.

For every call on my calendar today, write prep notes: who they are, what we last discussed, what they want from this call, what I want from it, and the one question I should ask.

Flag anything urgent at the top. Keep the whole thing under 400 words.

Noon, the delegation checkpoint. This is where you brief the afternoon and let it work while you are on calls:

Here is what needs to be done this afternoon: [YOUR LIST]

Read AGENTS.md first. Break this into parallel workstreams, spawn subagents for the pieces that do not depend on each other, and ask me anything you need before starting, because I am about to be unavailable for three hours.

When I come back, give me one summary: what is finished, what needs my review, what is blocked and on what.

5 PM, the audit checkpoint, and this is the one that makes it a loop:

Read AGENTS.md first, then audit today.

Report: what was completed, what is still pending and why, what carries over to tomorrow, and anything that has now slipped twice.

Then write tomorrow's opening context, so the morning checkpoint starts with today's state rather than from nothing. Save it as the end-of-day summary.

Finally, note anything I corrected you on today that should become a permanent rule, and propose where it belongs, in aboutme.md, style.md, or AGENTS.md. Propose only, I will approve it.

That last instruction is what makes the system improve. Corrections that only live in a chat get repeated next week. Corrections that get promoted into the context files never happen again.

The Honest Limit

One thing worth knowing before you scale this up. OpenAI's own team found that most engineers could comfortably manage three to five parallel sessions before context switching became genuinely painful, and that was engineers doing focused work.

The point of delegation is not running twenty things at once, it is that one instruction produces parallel work you do not have to supervise piece by piece. If you find yourself checking on six agents instead of doing your actual job, you have rebuilt the problem you were solving.

Same applies to the checkpoints. Three a day works because you actually read all three. Six a day becomes noise you skim, and a summary you skim is worse than no summary, because you believe you know what is happening.

The Rules That Keep It Working

The context files are the product. Update them every time the model gets something wrong, rather than correcting the output and moving on.

AGENTS.md is what makes context inheritable. Files it does not reference might as well not exist once delegation starts.

Keep max_depth at 1 until you have a specific reason not to.

Nothing sends without you. Drafts are the deliverable, especially for anything client-facing.

And read the 5 PM audit properly. It is the only checkpoint that compounds, because it is the one that feeds tomorrow.

The Recap

Build aboutme.md by letting the model interview you, style.md from your real published writing with a heavy prohibition list, and mycompany.md with your goals and priorities. Create AGENTS.md at the root pointing at all three, because that is what subagents actually inherit. Enable multi-agent in your Codex config with max_depth at 1. Then use one prompt structure forever, and run the three checkpoints so each day starts with yesterday's state.

Set up once, and the model stops being a chatbot you re-explain yourself to every morning.

Don't want to figure this out alone? I walk members through every step inside the community. Join the Skool → skool.com/raycfu