Autonomous Agents

You set up a research agent last week. It scraped the wrong website, got rate-limited, retried the same broken approach three times, and then asked you to approve every single file save. You fixed it, re-ran it, and it made the same mistake — because it forgot everything between sessions.

That's the old way. With autonomous execution, your agents remember what went wrong, run subtasks in parallel instead of one-by-one, and know when it's safe to skip the approval dialog. Each run makes them a little bit smarter.

Self-Learning Loop

Every time an agent finishes a task, Meggy extracts lessons from the execution log — what worked, what failed, and why. These lessons are stored in a local database, scoped to that specific agent.

The next time the agent runs, the most relevant lessons are automatically injected into its prompt. If a lesson keeps proving useful, its score goes up. If it becomes irrelevant, it fades away.

What This Looks Like in Practice

Say your "Weekly Report" agent fails because the analytics API returns a 429 error. After the run:

  1. Meggy detects the failure pattern and creates a lesson: "Rate-limit the analytics API to 2 requests per second"
  2. Next week, the agent sees this lesson in its prompt before it starts
  3. It adjusts its approach — and the report completes without errors

You didn't configure anything. The agent just got better.

Autonomy Levels

Not every tool call needs your blessing. Meggy offers three levels of human oversight:

Level What Happens Best For
Supervised Every tool call asks for your approval New agents you're still testing
Semi-Autonomous Safe actions auto-approved; risky ones still ask Agents with a track record
Autonomous Everything runs without asking ("YOLO mode") Trusted agents on a schedule

Even in YOLO mode, safety nets stay active. Budget limits, sandbox policies, and trust-level restrictions still apply — your agent can't break out of its containment just because approvals are turned off.

Level 4: Self-Scheduled Autonomy

The highest level of autonomy is an agent that manages its own time. By using Scheduled Tasks, you can configure agents to run even when the application is in the background or you are away from your desk.

Whether it's a daily briefing agent that prepares your morning report or a weekly maintenance agent that cleans up your local workspace, scheduled autonomy turns your AI from a reactive tool into a proactive partner.

Parallel Execution

By default, agents work through subtasks one at a time. Enable parallel execution and they tackle multiple subtasks simultaneously — like having three research assistants working at once instead of one.

You control the concurrency with a simple setting:

This is especially powerful for agents that do independent research across multiple sources. A "competitive analysis" agent checking five rival products finishes in the time it takes to check one.

Stall Detection & Turn Budgets

When you give an agent pure autonomy, what stops it from getting stuck in an infinite loop and burning through tokens? Meggy features granular Turn Budgeting and Stall Detection.

Beyond simple context limits, the engine actively monitors the agent's behavior mid-turn. If it detects a stall — for instance, if the agent makes five consecutive failing tool calls but produces an average of fewer than 20 meaningful outcome tokens per step — it cuts the loop, logs a failure, and forces a course correction. Your API budget remains safe, and the agent learns from the failure.

Failure Museum

Every failure tells a story. The Failure Museum captures structured records of what went wrong — the error, the context, the approach that was tried — and scores each record for future relevance.

When your agent starts a new approach on a task, the most relevant failure records are pulled in automatically. The agent sees "Last time you tried this, XYZ happened" and avoids repeating the same mistake.

Stale records are pruned automatically. If a failure hasn't been reinforced in a configurable period, it fades from the museum — keeping the advice fresh and relevant.

Browser & Git Tools

Two new capability classes expand what agents can do:

Browser automation lets agents interact with web pages — fill forms, take screenshots, scrape content. This is trust-gated: only your most trusted agents get browser access.

Desktop automation (Computer Use) gives agents native control over your machine — traversing UI accessibility trees, typing, clicking, and grabbing screenshots across apps.

Git integration gives agents source control capabilities — stage files, create commits, push branches. Same trust gating applies: restricted agents can read repository state but can't write to it.

Tool What It Does Trust Required
git_status Check working tree status Any
git_push Push to remote Root or Delegated
desktop_read_ui_tree Read screen accessibility elements Any
desktop_find_element Locate a specific UI element Any
desktop_click Click on a UI element or coordinate Root or Delegated
desktop_type Emulate keyboard typing Root or Delegated

Setting Up

  1. Open Agents → select your agent → Settings
  2. Under Execution Config, toggle Parallel Execution and set your slot count
  3. Choose your Autonomy Level — start with Semi-Autonomous and promote to Autonomous once you're confident
  4. Enable Browser Tools if the agent needs web interaction
  5. Self-learning and Failure Museum are active automatically — no configuration needed

What's Next?