100xprompt turns a plain-language request into finished engineering work. You describe an outcome; it reads your codebase, forms a plan, uses real tools to make changes, checks its own work, and asks before doing anything sensitive. This page is the mental model - what a session is, how the agent works in a loop, and how the pieces you configure fit together.
This is a conceptual overview. You don’t need any of it to be productive. But knowing how 100xprompt reasons helps you steer it, trust it, and get better results on long tasks.

​
Understand a session

A session is a single continuous conversation with 100xprompt about your project. It starts when you open 100xprompt in a directory and describe what you want. It holds everything the agent needs to work: your messages, what it has read and changed, the tools it has run, and the running plan for the task. Think of a session as the agent’s working memory for one job. The agent tracks context so you can go back and forth naturally - refine a request, correct course, or add a follow-up - without re-explaining what you’re building. When a task is done, start a fresh session for the next one, or keep going in the same thread.

One task, one thread

A session bundles the conversation, the changes, and the plan into a single place you can follow and resume.

Stays oriented

It remembers what it has learned about your codebase during the session, so context carries forward as the task grows.

You stay in control

Nothing sensitive happens without your say-so. You approve edits and commands as they come up.

​
Follow the core loop: plan, act, check

100xprompt doesn’t answer in one shot and hope for the best. It works in a loop, the way a careful engineer does. It gathers context, decides on the next concrete step, uses a tool to take that step, looks at the result, and repeats until the task is done. If something fails or a result is surprising, it adjusts and tries again instead of pushing ahead.
1

Understand

Before touching anything, 100xprompt reads the relevant parts of your codebase and searches for what it needs. It grounds its plan in how your project actually works, not in guesses.
2

Plan

It breaks the request into concrete steps. For larger tasks, it keeps a visible checklist so you - and it - can see what’s done and what’s next.
3

Act

It uses real tools to make progress: editing files, running commands, searching code, or fetching information. Each action is a deliberate step toward the outcome.
4

Check and self-correct

It inspects the result of each action. If a command fails, a test breaks, or an edit didn’t land as intended, it diagnoses the problem and revises its plan rather than charging on.
5

Finish

When the work is actually complete, it stops and summarizes what changed, so you can review the result and decide what’s next.
Self-correction is what makes 100xprompt reliable on real work. Because it reads the outcome of every action, it catches its own mistakes - a failing test, a typo, a missing import - and fixes them in the same session.

​
Stay in control with permissions

Reading and searching your code is safe, so 100xprompt does it freely. But anything that changes your project or your machine - editing files, writing new ones, or running shell commands - pauses for your approval first. You see exactly what it wants to do before it happens.
You decide how much to approve, and how often:
ChoiceWhat it means
Allow oncePermit this specific action, and be asked again next time.
Allow alwaysTrust this kind of action for the rest of the session so you’re not re-prompted.
RejectSkip this action; the agent adapts its plan around your decision.
Set standing permission rules in your configuration so routine, trusted actions run without interruption while sensitive ones still ask. See Permissions for the full model.
100xprompt never silently edits files or runs commands you haven’t approved. If you deny an action, it works around it - it won’t try to sneak past your decision.

​
Keep long tasks on track

Big requests span many steps, files, and tool runs. 100xprompt stays oriented with a running plan - a live checklist of what it intends to do, updated as it makes progress and marks steps complete. You watch the task advance in real time. As a session grows, the agent also manages its own working context so the important details stay front-of-mind across a long stretch of work. A multi-step task - refactor this module, wire up that integration, fix these tests - proceeds coherently from start to finish instead of losing the thread halfway through.
For work that should carry across sessions - your conventions, project facts, preferences - 100xprompt has a persistent Memory. That’s different from a session’s working context. See Memory & Context.

​
See how agents, models, and tools relate

Four ideas work together every time you use 100xprompt. Seeing how they nest makes the whole product click.

Agents

An agent is the role doing the work. A primary agent drives your session; it can hand off focused pieces of a task to specialized subagents that report back. You can also switch to a plan-first agent that investigates read-only before proposing changes.

Models

Behind every agent is a frontier model doing the reasoning. 100xprompt supports the most capable models and lets you choose which one handles a job - a heavyweight model for hard problems, a faster one for lighter work.

Tools

Tools are how the agent acts on the real world - reading and searching code, editing and writing files, running commands, and fetching information. Skills, Commands, and MCP connectors extend this toolbox with new abilities.

Permissions

Permissions are your guardrails. They sit across every action so you stay in control of what actually happens to your project and your machine.
Put simply: a session is the conversation, an agent does the work inside it using a model to reason and tools to act, and permissions keep you in the loop. That’s the whole loop - describe, plan, act, check, and finish, with you approving the moments that matter.

​
Common questions

No. You describe the outcome in plain language and 100xprompt forms the plan. For large or ambiguous work, you can start with a plan-first approach to review the approach before any changes are made.
The agent reads the result of each action. If a command fails or an edit didn’t work as intended, it diagnoses the issue and revises its plan - self-correcting within the same session rather than handing you a broken result.
No. Reading and searching are automatic, but edits, new files, and shell commands pause for your approval. You can grant standing permission for trusted actions so you’re only interrupted for the ones that matter.
It keeps a live checklist of steps and updates it as it goes, and it manages its working context so the key details stay in focus. You can follow progress in real time and pick the task back up in the same session later.

Capabilities Overview

The full range of what 100xprompt can do across your codebase and tools.

Agents

Primary agents, subagents, and how to direct them at focused work.

Permissions

Set the guardrails - what runs freely, what asks, and what’s off-limits.