HIL vs Autonomous: Two Philosophies of AI Agents 🤖

Published: January 8, 2025

In the world of AI agents, there are two fundamentally different approaches: Human-in-the-Loop (HIL) and Fully Autonomous. DevDuck and Strands-Coder represent these two philosophies. Let's explore what makes each unique.

The Spectrum

graph LR
    subgraph "HIL Territory"
        D1[Copilot]
        D2[DevDuck]
        D3[Claude Chat]
    end

    subgraph "Autonomous Territory"
        A1[Strands-Coder]
        A2[AutoGPT]
        A3[Devin]
    end

    D1 ---|More Human Control| D2
    D2 ---|Hybrid| A1
    A1 ---|More Agent Autonomy| A2

    style D2 fill:#bbf,stroke:#333,stroke-width:4px
    style A1 fill:#bfb,stroke:#333,stroke-width:4px

DevDuck: Partial HIL Agent

sequenceDiagram
    participant H as Human
    participant D as DevDuck
    participant T as Tools

    H->>D: Query
    D->>D: Process
    D->>T: Execute (with consent)
    T->>D: Result
    D->>H: Present result
    H->>H: Review & decide next step

    Note over H,D: Human stays in control

Key Characteristics

DevDuck Philosophy

Interactive REPL: Human types, agent responds
Shell prefix: ! for direct commands
Hot reload: Human can modify agent while running
Ambient mode: Agent thinks in background, but human reviews
Tool consent: BYPASS_TOOL_CONSENT controls automatic execution

The Ambient Mode Bridge

DevDuck's ambient mode is a hybrid approach:

stateDiagram-v2
    [*] --> HumanActive
    HumanActive --> Idle: 30s no input
    Idle --> AmbientThinking: Agent explores
    AmbientThinking --> ResultsReady
    ResultsReady --> HumanActive: Human returns

    Note right of AmbientThinking: Agent works<br/>autonomously
    Note right of ResultsReady: Results injected<br/>into next query

# Enable ambient mode
🦆 ambient

# Agent thinks while you're idle
🌙 [ambient] Thinking... (iteration 1/3)
# ... explores related topics ...

# Your next query includes ambient findings
🦆 what did you find?
# Response includes ambient context automatically

Strands-Coder: Fully Autonomous Agent

sequenceDiagram
    participant GH as GitHub Event
    participant A as Strands-Coder
    participant T as Tools
    participant KB as Knowledge Base

    GH->>A: Trigger (issue/PR/cron)
    A->>KB: Retrieve context
    A->>A: Reason & plan
    loop Until complete
        A->>T: Execute action
        T->>A: Result
        A->>A: Evaluate & adjust
    end
    A->>KB: Store learnings
    A->>GH: Commit results

    Note over A: No human intervention

Key Characteristics

Strands-Coder Philosophy

Event-driven: Responds to GitHub events automatically
Scheduled: Runs on cron without human trigger
Self-improving: Updates own system prompt
Memory: Continuous learning via knowledge base
Sub-agents: Can spawn child agents for parallel work

The Control Loop

# control.yml - Hourly autonomous check
on:
  schedule:
    - cron: '0 * * * *'  # Every hour

jobs:
  control:
    runs-on: ubuntu-latest
    steps:
      - name: Check Schedules and Dispatch Jobs
        run: |
          # Parse AGENT_SCHEDULES
          # Check which jobs are due
          # Dispatch to agent.yml

Comparison

Aspect	DevDuck (HIL)	Strands-Coder (Autonomous)
Trigger	Human query	GitHub events / cron
Runtime	Terminal session	GitHub Actions
Persistence	Session-based	Knowledge base + S3
Control	Human reviews each step	Pre-defined rules
Learning	Hot reload / manual	Automatic via KB
Scope	Single machine	Multi-repo ecosystem
Risk	Low (human oversight)	Medium (guardrails needed)

When to Use Each

flowchart TD
    Start[Need AI Help] --> Q1{Real-time interaction?}
    Q1 -->|Yes| Q2{Local development?}
    Q1 -->|No| Q3{Repetitive task?}

    Q2 -->|Yes| DevDuck[Use DevDuck]
    Q2 -->|No| Q4{Multi-machine?}

    Q3 -->|Yes| Strands[Use Strands-Coder]
    Q3 -->|No| Q5{Event-driven?}

    Q4 -->|Yes| Swarm[DevDuck Swarm]
    Q4 -->|No| DevDuck

    Q5 -->|Yes| Strands
    Q5 -->|No| DevDuck

    style DevDuck fill:#bbf
    style Strands fill:#bfb
    style Swarm fill:#fbf

Use DevDuck When:

You need real-time interaction
Tasks require human judgment
You're developing locally
You want to see and control each step

Use Strands-Coder When:

Tasks are well-defined and repetitive
You need 24/7 availability
Work spans multiple repositories
Events should trigger actions automatically

The Hybrid Future

graph TB
    subgraph "Human Layer"
        Dev[Developer]
    end

    subgraph "HIL Layer"
        DD[DevDuck Terminal]
        Swarm[DevDuck Swarm]
    end

    subgraph "Autonomous Layer"
        SC[Strands-Coder]
        Sub[Sub-Agents]
    end

    Dev <-->|Interactive| DD
    DD <-->|Coordinate| Swarm
    DD -->|Spawn| SC
    SC -->|Delegate| Sub
    Sub -->|Report| SC
    SC -->|Notify| DD
    DD -->|Present| Dev

    style DD fill:#bbf
    style SC fill:#bfb

The future isn't HIL or autonomous - it's both working together:

Developer works interactively with DevDuck
DevDuck spawns autonomous tasks to Strands-Coder
Strands-Coder delegates to sub-agents
Results flow back to developer for review

Example Workflow

# In DevDuck terminal
🦆 analyze the strands-agents repos for improvement opportunities

# DevDuck responds
"I'll spawn an autonomous agent to scan all repos. 
 It will run for the next 4 hours and report back."

# DevDuck creates a scheduled job
create_subagent(
    repository="cagataycali/strands-coder",
    workflow_id="agent.yml",
    prompt="Scan all strands-agents repos for improvement opportunities",
    system_prompt="Report findings in issue #improvement-scan",
)

# 4 hours later, notification appears
🦆 "Strands-Coder found 12 improvement opportunities. 
    See issue #improvement-scan for details."

Building Your Own Hybrid

Step 1: Start with DevDuck

$ devduck
🦆 what can I help with?

Step 2: Enable Ambient Mode

🦆 ambient
🌙 Ambient mode enabled

Step 3: Configure Strands-Coder

# In your repo's .github/workflows/agent.yml
- uses: cagataycali/strands-coder@main
  with:
    prompt: ${{ github.event.inputs.prompt }}

Step 4: Connect Them

# In DevDuck, spawn autonomous tasks
🦆 create a scheduled job to review PRs daily at 9 AM

# DevDuck uses scheduler tool
scheduler(
    action="add",
    job_id="daily_pr_review",
    cron="0 9 * * *",
    prompt="Review all open PRs and provide feedback"
)

The best AI systems know when to ask and when to act. 🤖