OpenAI Dots: Build a ChatGPT Agent That Works in 9 Steps

I’ll admit something. Most of my ChatGPT sessions follow the same pattern. I ask, I get an answer, then I ask again. Somewhere along the way I became the project manager of a chatbot, and that’s not a job I applied for.

That’s why this post from an AI professional on LinkedIn caught my eye right away. The author opens with one bold line: ChatGPT just stopped waiting for your next prompt. They then explain OpenAI Dots, which are persistent agents that live inside ChatGPT. You give a Dot a goal, it keeps working in the background, and it only comes back when it needs your input. In the author’s words, “That’s the whole shift.”

The creator also shows exactly how to set one up and how much freedom to give it. I’ve turned their breakdown into a step-by-step guide you can follow today.

😩 The Old Way Is Wearing Us Out

The original poster sums up the old way perfectly. Most people still use AI like this:

• Same context pasted into every chat
• Same instructions retyped every week
• Every task babysat from start to finish

The author points out a lesson they spent a year learning: delegation fails without clear boundaries. According to them, Dots work exactly the same way. A human assistant needs a clear brief, and so does an AI agent. That idea runs through every step below.

🤖 What a Dot Can Actually Do

Before you build one, it helps to know what’s possible. Here’s what the expert says a Dot can handle:

• Use its own cloud computer and connected plugins
• Run scheduled tasks and remember context
• Browse the web and do proactive research
• Delegate to Work and Codex
• Optionally use your local computer
• Ask for approval before sensitive actions

That last point matters a lot. A Dot isn’t a loose cannon. You decide when it needs to check with you first.

📝 The Instruction Formula

Every good Dot starts with good instructions. The post’s author shares a simple seven-part formula:

Role, Goal, Context, Tools, Schedule, Boundaries, Approval Rules.

The creator ends their own instructions with a safety line that I think everyone should copy: “never publish, send messages, delete files or spend money without my approval.” It’s short, clear, and it stops the scariest mistakes before they happen.

🛠️ Create Your First Dot in 9 Steps

Now for the main event. Here’s the nine-step process this contributor lays out, plus why each step matters:

1. Create it in ChatGPT. Everything starts inside the tool you already use, so there’s no new app to learn.
2. Give it a clear role. A role like “content operations assistant” tells the Dot how to think and what falls inside its lane.
3. Define its goal. A specific outcome, like “prepare a weekly competitor summary,” gives it something to measure success against.
4. Add relevant context. This is where you stop pasting the same background into every chat. Give it once and the Dot remembers.
5. Connect required plugins. Only connect the tools it needs for the job. Fewer tools means fewer chances for mistakes.
6. Set custom rules and permissions. This is your safety net. Decide what it can do alone and what needs your sign-off.
7. Define recurring tasks. Scheduled work is where Dots shine, because they keep going without you nudging them.
8. Give it a first assignment. Start with something small and real so you can watch how it performs.
9. Review and refine its work. Treat the first few outputs as a trial run, then tighten your instructions based on what you see.

🪜 Climb the Autonomy Ladder Slowly

Once your Dot is running, the next question is how much freedom to give it. The author describes a six-level autonomy ladder:

1. Level 1: Research
2. Level 2: Recommend
3. Level 3: Prepare
4. Level 4: Act with approval
5. Level 5: Perform narrowly pre-approved actions
6. Level 6: Handle routine tasks independently

I love this framework because it makes trust something you build step by step. Start at the bottom and move up only when the Dot proves itself.

Custom rules also let you choose the level per task. For each one, you can tell the Dot to act automatically, act when pre-approved, ask before acting, or hand it back to you. So your Dot could draft social posts on its own while still asking before it emails a client.

✅ Best Practices From the Author

To keep your Dots useful and safe, the expert recommends:

• ✔ One clear responsibility per Dot
• ✔ Specific outcomes and explicit boundaries
• ✔ Only the tools it needs
• ✔ Start with limited permissions and add autonomy gradually
• ✔ Verify important outputs and review activity regularly

⚠️ Where Humans Stay in Charge

The original poster is careful about high-stakes work. They suggest keeping humans in control of:

• Money
• Legal commitments
• Passwords
• Confidential info
• Destructive actions
• Client communication
• Irreversible decisions

If a mistake would be expensive, embarrassing, or impossible to undo, it belongs to you, not the Dot. That simple filter keeps the whole system safe.

💡 Where Dots Fit Best

So where should you start? The author lists these strong use cases:

• Personal chief of staff
• Content operations
• Marketing workflows
• Research
• Project management
• Software development
• Sales ops
• Meeting prep
• Business ops
• Learning

My suggestion is to pick something low-risk and repetitive first. Meeting prep or weekly research are great starting points. If the Dot gets it wrong, nothing breaks, and you learn how to write better instructions.

🔁 The Loop Behind Every Dot

Finally, the creator ties everything together in one loop:

Responsibility → Context → Tools → Memory → Schedule → Rules → Approvals → Human oversight.

Their closing advice is simple. Define the goal, tools, permissions and boundaries, then let it run. They also ask a great question: where would you trust a Dot first? I’m still thinking about my answer.

If you know someone who still copy-pastes prompts all day, send this their way. And check out the full LinkedIn post to see the original breakdown and join the conversation.