Codex Terms Explained: Task, Thread, and Subagent from the Perspective of a New Chat
When using Codex, you may see the terms “task,” “thread,” and “subagent.” They often appear in similar situations, which makes it difficult to tell whether a term means a new chat, a conversation history, or an AI worker delegated by another AI.
This article gives a practical explanation rather than making claims about every internal implementation. Labels and controls can differ across Codex clients, so the goal is to establish a useful vocabulary for everyday work.
The three terms in one table
| Term | What it means | Practical interpretation |
|---|---|---|
| Task | The unit of work or goal to complete | One outcome such as drafting an article or fixing a bug |
| Thread | The container for conversation, instructions, and execution history | The conversation opened as a new chat |
| Subagent | An AI that handles work delegated from a parent task | A worker started from the main thread and expected to return a result |
In casual conversation, task and thread can be used almost interchangeably. A useful distinction is: task answers “what are we trying to finish?” while thread answers “which conversation history are we using?”
What happens when you open a new chat?
Opening a new Codex chat creates a place where messages, tool calls, file changes, and decisions accumulate. In AI Jiten’s terminology, we call the single goal pursued in that new chat a task.
For example, if you open a new chat to write an Obsidian article, the chat is the main thread and the article is one task. As long as you continue in that chat, you can use the shared history and decisions.
The official manual recommends continuing one chat for one coherent unit of work and starting a new chat for a distinct outcome. Opening a new chat separates the conversation, while a task is the outcome that conversation is meant to achieve.
Think of a thread as a conversation container
A thread contains the user’s instructions, AI responses, tool execution, file changes, and decisions. When you say “continue in this thread,” you are asking Codex to use that same history.
A separate thread can still work in the same project or folder, but its conversation context is separate. You need to pass the necessary background again.
Forking a chat or opening a new chat creates another conversation path. Shared files do not necessarily mean that the conversation context is automatically shared.
A subagent is an AI responsible for part of a task
A subagent is not simply a new chat opened by the user. It is an AI worker that the parent agent starts after delegating a bounded piece of work such as research, testing, or review.
A subagent also has its own agent thread. The relationship can be pictured like this:
- Parent task: the overall outcome
- Parent thread: the main conversation pursuing that outcome
- Subagent: the worker responsible for one delegated part
- Subagent thread: the conversation where that worker operates
The important difference is the delegation relationship. A standalone new chat does not automatically become a subagent.
Why the distinction matters for the Luna workaround
When a model is not listed among the available subagent candidates, you may start a separate thread with that model as the main model. That thread is not a child of the original task.
It is better described as a separate task in the same project. You can pass it the goal, target files, and completion criteria, and you can review its progress, but it may not automatically return a subagent-style summary to the parent.
Calling it a “Luna subagent” can therefore make the model and history behavior confusing. In this situation, use “Luna thread” or “separate Luna task” instead.
How AI Jiten will use these terms
- Task: one goal or deliverable started from a new chat
- Thread: the conversation history and work unit used to pursue that task
- Subagent: an AI delegated a bounded part of a parent task and running in its own thread
A UI label may say “task” even when it is referring to a conversation thread. When in doubt, translate task as goal, thread as history, and subagent as delegated worker.
Summary
Task, thread, and subagent overlap, but they describe different scopes. A task is the goal, a thread is the conversation container, and a subagent is the worker delegated part of the task.
Use “new task” or “new thread” when you start independent work yourself. Use “subagent” when a parent agent delegates a bounded job and expects a result back.
The official Codex manual describes separate chats for distinct outcomes and separate agent threads for subagents. Client labels and controls may change, so this article prioritizes a practical distinction that is easy to apply while working.
