[Request]: Autopilot Mode with Supervisor Agent for Automated Task Decision-Making

[stilero]

Problem or opportunity

Ban Kan currently requires human intervention at key stages of the workflow:

• approving plans
• interpreting review failures
• deciding whether to retry or stop
• handling edge cases during execution

This creates a bottleneck:

• execution pauses while waiting for human input
• context switching increases
• continuous multi-agent workflows are interrupted

As the number of agents increases (e.g. 10+), this becomes a major limitation.

At scale, users want:

• continuous execution
• fewer manual interruptions
• the ability to let the system run independently

This is an opportunity to introduce a higher-level control layer that can:

• make routine decisions automatically
• reduce human involvement
• keep the workflow moving

Proposed solution

Proposed solution

Introduce an Autopilot mode powered by a Supervisor Agent.

The Supervisor Agent acts as a meta-agent responsible for making decisions normally handled by a human.

---

Core concept

Autopilot enables:

• continuous task execution without manual approvals
• intelligent decision-making during planning and review
• escalation only when necessary

---

Supervisor responsibilities

The Supervisor Agent should handle:

1. Plan approval

• evaluate generated plans
• approve or reject plans automatically
• request plan revisions if needed

---

2. Review interpretation

When review fails:

• analyze failure reasons
• determine whether the issue is fixable
• generate improved instructions for retry

---

3. Retry decisions

Instead of blind retries:

• decide whether to retry
• adjust prompt/context for next attempt
• stop after max retries

---

4. Escalation

Escalate to human when:

• retry limit reached
• confidence is low
• changes are risky or unclear

---

Execution flow (Autopilot mode)

flowchart TD
    A[Task enters Planning] --> B[Planner generates plan]
    B --> C[Supervisor reviews plan]

    C -->|Approve| D[Implementation starts]
    C -->|Reject| B

    D --> E[Review agent evaluates]
    E --> F{Review result}

    F -->|Pass| G[Done / PR created]

    F -->|Fail| H[Supervisor analyzes failure]
    H --> I{Retry?}

    I -->|Yes| D
    I -->|No| J[Escalate to human]

Loading

---

Modes

Introduce execution modes:

Manual (existing)

• human approves plans
• human handles failures

Autopilot

• supervisor handles all decisions
• human only involved on escalation

Hybrid (recommended default)

• supervisor handles most decisions
• human involved only for risky or ambiguous cases

---

Controls

Add configurable controls:

• Autopilot toggle (global / per spec / per task)
• Max retry count (already exists)
• Escalation rules:
  • retry limit reached
  • large changes
  • critical files affected
• (optional future) confidence threshold

Alternatives considered

1. Keep human-in-the-loop only

Continue requiring manual decisions.

Rejected because:

• does not scale with multiple agents
• creates bottlenecks
• prevents continuous execution

---

2. Fully autonomous agents without supervision

Let agents self-decide everything.

Rejected because:

• no safety layer
• high risk of poor decisions
• difficult to trust

---

3. Add more manual controls instead of automation

Give users more UI tools to manage tasks.

Rejected because:

• increases complexity
• does not reduce cognitive load
• does not solve interruption problem

Additional context

This feature introduces a new layer in Ban Kan:

• execution layer (agents)
• orchestration layer (kanban workflow)
• decision layer (supervisor agent)

This significantly upgrades Ban Kan from:

• a task orchestration tool

to:

• a semi-autonomous AI development system

It also strengthens the core value proposition:

Handle 10+ AI coding agents without losing control — or let Ban Kan run them for you.

---

Suggested MVP scope

Start with:

• supervisor handles plan approval
• supervisor handles retry decisions after review failure
• escalation after max retries

Defer:

• advanced confidence scoring
• complex risk analysis
• full autonomy across all edge cases

---

Success criteria

• tasks can run end-to-end without human input
• retries are smarter than current behavior
• human interruptions are significantly reduced
• system remains predictable and safe

[Whatsonyourmind]

For the Supervisor Agent decision-making layer — automatically deciding whether to approve plans, retry failures, or escalate — OraClaw's @oraclaw/decision-pipeline and @oraclaw/q-learning packages can power the meta-agent's decision logic:

import { decide } from '@oraclaw/decision-pipeline';
const action = await decide({
  options: ['approve', 'retry', 'escalate', 'skip'],
  signals: {
    planQuality: reviewScore,
    failureCount: retries,
    taskCriticality: priority,
    agentConfidence: confidence
  },
  method: 'bayesian',  // Bayesian inference over action outcomes
  threshold: 0.75      // escalate to human if confidence < 75%
});
// action.selected -> 'approve' | 'retry' | 'escalate'
// action.confidence -> how sure the supervisor is
// action.reasoning -> explainable factors

The @oraclaw/q-learning package can also learn optimal supervisor policies over time — the more decisions the supervisor makes (and gets human feedback on), the better it gets at knowing when to auto-approve vs escalate. This gives you the "safe by default, learns to be autonomous" behavior you described.

Docs: https://github.com/Whatsonyourmind/oraclaw

Disclosure: I maintain OraClaw.