Skip to main content
Miteos agents can run fully autonomously — but that doesn’t mean you have to let them. Human-in-the-loop controls let you step in at any point: pause an agent mid-run, take over its browser, send a course-correction message, or require explicit approval before agents take sensitive actions like sending emails, executing trades, or making purchases.

​
When to Use Human-in-the-Loop

You don’t need to intervene in every task, but some situations call for a human checkpoint:
  • Sending emails or messages — Outbound communication on your behalf should always be reviewed before it reaches real recipients.
  • Executing live trades — Even if your strategy is sound, trade execution in live markets carries financial risk. Always start with paper trading.
  • Making purchases — Any transaction involving real money needs human sign-off, even with trusted vendors.
  • Publishing to social media — Posts are public and permanent. A review step prevents embarrassing or off-brand content from going live.
  • Deleting or overwriting data — Destructive actions on files, databases, or records should require explicit approval.
  • Accessing sensitive credentials — If an agent needs to authenticate to a system it hasn’t used before, pause and verify.

​
Setting Autonomy Level

The Autonomy Level (0–100) is the primary dial for human-in-the-loop control. Lower values mean more checkpoints; higher values mean more freedom.
RangeModeWhat it means
0–20CopilotAgent suggests every action and waits for your confirmation before proceeding.
20–50SupervisedAgent handles low-risk actions autonomously; pauses and asks for high-risk ones.
50–80AutonomousAgent handles most actions independently; pauses only for critical decisions.
80–100Full AutoAgent executes everything and notifies you after the fact.
Set autonomy when you create a task or update it at any point from the War Room header. For more detail on what “high-risk” and “critical” mean in each mode, see Autonomy Level.

​
Pausing and Resuming Agents

You can pause any running agent at any time from the War Room — useful when you spot something in the Timeline that needs review, or when you want to redirect the agent before it proceeds.
1

Click Pause on the agent card

In the Agent Fleet Rail, find the agent you want to pause and click the ⏸ Pause button on its card. The agent will complete its current atomic action (finishing a page load, completing a line of code) before stopping cleanly.
2

Review what the agent is doing

With the agent paused, check the Workspace panel to see its current browser state, the files it has open, and the last few entries in the Timeline. This gives you full context before you decide what to do next.
3

Send guidance or resume

You have two options:
  • Send guidance — type a correction message in the guidance field (see Sending Mid-Task Guidance below) then click Resume.
  • Resume directly — click ▶ Resume to let the agent continue exactly where it left off.
Pause and resume via the API: 
# Pause a running agent
curl -X POST https://api.miteos.com/v1/agents/{id}/pause \
  -H "Authorization: Bearer mt_live_xxx"

# Resume later
curl -X POST https://api.miteos.com/v1/agents/{id}/resume \
  -H "Authorization: Bearer mt_live_xxx"

​
Sending Mid-Task Guidance

You can send a plain-language message to a running (or paused) agent at any time. The agent reads your message as high-priority context and incorporates it into its next actions — you don’t have to cancel and restart the task. In the War Room, open the Guide input at the bottom of any agent card, type your message, and press Send. Examples of useful mid-task guidance:
  • “Focus only on US market data, ignore European sources.”
  • “The output format should be a Google Sheets-compatible CSV, not a Markdown table.”
  • “Skip the LinkedIn results — we don’t have an account connected.”
  • “The competitor you’re researching is Notion, not Notino — please correct the search.”
Send guidance via the API: 
curl -X POST https://api.miteos.com/v1/agents/{id}/guide \
  -H "Authorization: Bearer mt_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"message": "Focus only on US market data, ignore European sources"}'
Guidance is non-destructive — it doesn’t restart the agent or wipe its progress. Think of it as whispering a correction to a colleague mid-meeting.

​
Approval Gates

When an agent reaches an action that requires human sign-off (based on your autonomy level or the action’s risk category), it pauses and raises an approval request. You’ll see an orange badge on the agent card in the War Room and receive a notification. Each approval request shows:
  • What the agent wants to do — e.g., “Send this email to 3 recipients”
  • The full payload — the email body, recipients, or trade order details so you can review exactly what will happen
  • Approve / Deny buttons — approve to proceed, deny with an optional reason to redirect the agent
Approve or deny via the API: 
# Approve an action
curl -X POST https://api.miteos.com/v1/agents/{agent_id}/approve/{approval_id} \
  -H "Authorization: Bearer mt_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"approved": true}'

# Deny an action and redirect the agent
curl -X POST https://api.miteos.com/v1/agents/{agent_id}/approve/{approval_id} \
  -H "Authorization: Bearer mt_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"approved": false, "reason": "Use only the approved vendor list"}'
Approval requests time out after 15 minutes by default. If no response is received, the agent pauses the task and notifies you. Adjust the timeout in your workspace settings if your review process takes longer.

​
Browser Takeover

Every agent runs its own browser session you can see live in the Workspace panel. If you want to take direct control — fill in a form yourself, navigate to a specific page, handle a CAPTCHA — you can take over the agent’s browser at any time.
1

Click Takeover in the War Room

While the agent’s browser is visible in the Workspace panel, click the Takeover button in the top-right of the browser viewport. The agent immediately pauses its browser actions and hands control to you.
2

Complete the action manually

You now control the browser just like a normal tab. Navigate, click, type, upload files — whatever the task requires. The agent watches your actions and updates its context accordingly.
3

Hand back control

Click Return Control when you’re done. The agent resumes from the current browser state, incorporating everything you did into its understanding of where it is in the task.
Browser takeover is particularly useful for logging into services that use two-factor authentication, handling payment flows, or navigating paywalled content the agent can’t access on its own.

​
Handling Webhooks for Approvals

For production workflows, you’ll want to respond to approval requests programmatically rather than watching the War Room manually. Register a webhook endpoint to receive approval.required events and respond via the API. Register your webhook: 
import { Miteos } from '@miteos/sdk';

const client = new Miteos({ apiKey: 'mt_live_xxx' });

await client.webhooks.create({
  url: 'https://your-app.com/webhooks/miteos',
  events: ['approval.required', 'task.complete', 'agent.error'],
  secret: 'whsec_your_signing_secret',
});
Handle the approval.required event in your server: 
// Example: Express.js webhook handler
app.post('/webhooks/miteos', async (req, res) => {
  const event = req.body;

  if (event.type === 'approval.required') {
    const { agent_id, approval_id, action, payload } = event.data;

    // Your business logic — e.g. check if the trade size is within limits
    const approved = payload.trade_size_usd < 500;

    await client.agents.approve(agent_id, approval_id, {
      approved,
      reason: approved ? undefined : 'Trade exceeds $500 per-order limit',
    });
  }

  res.sendStatus(200);
});
Always verify the webhook signature using your whsec_ secret before processing events. The SDK’s client.webhooks.verify(payload, signature, secret) helper handles this automatically.