Why won't my Docker container start?

**Getting "docker: Error response from daemon: failed to set up container networking"** Port 8080 is taken by something else. Check what's using it: ```bash lsof -i :8080 netstat -tulpn | grep :8080 ``` Kill the process or change the port in your docker-compose.yml: ```yaml ports: - "8081:8080" # Use 8081 instead ```

Claude takes screenshots but won't click anything

This is usually a coordinate calculation problem. Check your screen resolution: ```bash xrandr # Linux system_profiler SPDisplaysDataType # macOS ``` Claude works best at **1280x800 resolution**. Higher resolutions cause pixel calculation errors. Set your container display to this resolution: ```bash export DISPLAY_WIDTH=1280 export DISPLAY_HEIGHT=800 ```

WSL2 Docker integration completely broken

**Getting "Docker Desktop is not running" (even though the fucking thing is clearly running)** This WSL2 integration failure happens constantly with Docker Desktop 4.24+ on Windows 11. Fix it: Stop Docker completely, then run this PowerShell bullshit as admin: ```powershell wsl --shutdown wsl --unregister docker-desktop wsl --unregister docker-desktop-data ``` Restart Docker Desktop and enable WSL2 integration again in Docker Desktop settings.

API authentication keeps failing

**Getting "authentication_error" even though I copy-pasted the damn key three times** Check these common causes: - API key has spaces/newlines (copy-paste error) - Using wrong environment variable name - Key doesn't have Computer Use beta access Test your key directly: ```bash curl -H "x-api-key: YOUR_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: computer-use-2025-01-24" \ https://api.anthropic.com/v1/messages ```

Container displays black screen

**VNC showing black screen or dying immediately** X11 forwarding is broken. Common fixes: Linux users can try this: ```bash xhost +local:docker # Allow Docker X11 access export DISPLAY=:0 ``` macOS with XQuartz needs this completely different bullshit: ```bash xhost +localhost export DISPLAY=host.docker.internal:0 ``` Windows users are fucked. Use Linux or macOS instead. Windows X11 forwarding is more broken than a 2003 Honda Civic.

Claude gets stuck in infinite loops

**Claude taking 100+ screenshots without doing anything useful** (yeah, that's your weekend budget gone) This happens when Claude can't find the element it's looking for. Check: 1. **Modal dialogs** - Claude can't see through popups 2. **Dynamic loading** - Page still loading when Claude tries to click 3. **Shadow DOM elements** - Invisible to Computer Use 4. **Changed UI** - Buttons moved since last working session Add timeouts to prevent runaway costs (learned this the hard way after a $800 bill): ```python max_actions = 50 # Limit actions per task action_timeout = 30 # Seconds per action max_daily_screenshots = 1000 # Emergency brake at ~$20/day current_screenshot_count = 0 ```

Claude says it clicked something but nothing happened

This is the classic "phantom click" problem. Claude reports successful action but the UI doesn't respond. **Root Causes:** 1. **Window focus lost** - Click went to wrong application 2. **Modal dialog blocking** - Hidden popup intercepted the click 3. **Coordinate drift** - UI element moved between screenshot and action 4. **Security policy** - Application blocked simulated input **Debugging Steps:** ```bash # Check current mouse position after \"click\" docker exec computer-use xdotool getmouselocation # Verify which window received the click docker exec computer-use xprop _NET_ACTIVE_WINDOW # Test manual click at same coordinates docker exec computer-use xdotool mousemove X Y click 1 ``` **Solution Pattern:** ```python # Add verification after each click def verified_click(x, y, timeout=3): screenshot_before = take_screenshot() perform_click(x, y) time.sleep(0.5) screenshot_after = take_screenshot() if screenshots_identical(screenshot_before, screenshot_after): raise ClickFailedException(\"UI didn't change after click\") ```

Computer Use bills are exploding beyond budget

**Symptom:** $2000+ monthly bills when you expected $50 (welcome to AI hell) This happens when Claude gets stuck taking expensive screenshots in loops. Screenshots cost about 2 cents each. When Claude gets stuck in a loop taking one every second, you'll burn $500+ per day. Found this out the expensive way after leaving a broken automation running over the weekend - came back Monday to a $1,400 bill because Claude spent 48 hours taking screenshots of a modal dialog it couldn't close. **Emergency Cost Controls:** ```python # Circuit breaker I hacked together after the third $800+ bill in two weeks max_screenshots_per_hour = 200 # About $4/hour max daily_limit = 50 # Kill it before it hits triple digits def emergency_brake(): if screenshot_count > max_screenshots_per_hour: print(\"STOP BURNING MONEY\") exit(1) ``` **Monitoring Setup:** ```bash # Set up billing alerts in your cloud console # AWS CloudWatch, Google Billing, or Azure Cost Management ```

UI elements keep moving and breaking automation

**Modern web apps are designed to break automation. Thanks, JavaScript.** **Problems:** - CSS animations move buttons during click - Dynamic loading changes element positions - Responsive design shifts layouts - JavaScript frameworks rerender components **Stability Strategies:** 1. **Wait for animations to complete:** ```python time.sleep(2) # Let CSS animations finish - ugly but works ``` 2. **Target static elements:** - Use text labels instead of icon buttons - Click form field labels, not the fields themselves - Target stable navigation elements 3. **Multiple targeting attempts:** ```python def robust_click(text_to_find, max_attempts=3): for attempt in range(max_attempts): try: screenshot = take_screenshot() coordinates = find_text(screenshot, text_to_find) click(coordinates) return True except ElementNotFoundException: time.sleep(1) # Wait for dynamic content raise Exception(f\"Could not find {text_to_find} after {max_attempts} attempts\") ```

Docker container runs out of memory and crashes

**Error:** Container exits with code 137 (OOMKilled) Computer Use + VNC + browser can easily exceed default memory limits. **Memory Investigation:** ```bash # Check current memory usage docker stats computer-use --no-stream # Check Docker memory limits docker inspect computer-use | grep -i memory # Check system memory pressure free -h ``` **Memory Optimization:** ```yaml # docker-compose.yml services: computer-use: mem_limit: 4g memswap_limit: 4g environment: - VNC_MEMORY_LIMIT=2048 # Limit VNC buffer - BROWSER_MEMORY_LIMIT=1024 # Limit browser ```

Authentication problems with corporate SSO

**Claude can't log into enterprise applications** Computer Use struggles with (and so will you): - Multi-factor authentication (Claude can't receive SMS) - CAPTCHA challenges (ironically, an AI can't pass anti-AI tests) - OAuth redirects (breaks the automation flow) - Session timeouts (corporate SSO expires every 30 minutes) - Hardware tokens/YubiKeys (obviously) - Conditional access policies (\"This looks suspicious\") **Workaround Strategies:** 1. **Pre-authenticated sessions:** ```bash # Start with user already logged in docker run -v /home/user/.config:/config computer-use ``` 2. **Session management:** ```python def maintain_session(): \"\"\"Keep session alive\"\"\" while True: try: take_screenshot() # Look for \"session expired\" indicators if find_text(screenshot, \"Sign In\"): trigger_human_intervention() except: time.sleep(300) # Check every 5 minutes ``` 3. **Human handoff points:** ```python def handle_auth_challenge(): \"\"\"Stop automation for human intervention\"\"\" screenshot = take_screenshot() if any(indicator in screenshot for indicator in [\"2FA\", \"CAPTCHA\", \"MFA\"]): send_notification(\"Human intervention required for authentication\") pause_automation() ```

Claude can't handle complex multi-step workflows

**Breaking down into reliable smaller tasks** Computer Use fails on workflows with 10+ steps. Success rate drops exponentially with task complexity. **Workflow Decomposition:** ```python # Instead of one complex workflow def complex_workflow(): step1() # 90% success step2() # 90% success step3() # 90% success # Overall: 90%^3 = 73% success rate # Break into independent, verifiable steps def reliable_workflow(): result1 = step1_with_verification() if not result1.success: retry_step1() result2 = step2_with_verification() if not result2.success: retry_step2() # Each step has 95%+ success with verification ``` **Checkpoint Strategy:** ```python class WorkflowCheckpoint: def __init__(self): self.completed_steps = [] def save_progress(self, step_name, data): self.completed_steps.append({ 'step': step_name, 'timestamp': datetime.now(), 'data': data }) def resume_from_failure(self): \"\"\"Skip already completed steps\"\"\" return self.completed_steps[-1] if self.completed_steps else None ```

Performance is unacceptably slow

**Each action takes 5-10 seconds, automation slower than humans** **Performance Bottlenecks:** 1. **API latency:** 1-3 seconds per request 2. **Screenshot processing:** Large images take time to analyze 3. **Network overhead:** Upload/download screenshot data 4. **UI response time:** Waiting for page loads **Optimization Techniques:** ```python # Reduce screenshot resolution for speed FAST_RESOLUTION = (800, 600) # Instead of (1280, 800) # Batch actions when possible def batch_text_input(text_chunks): \"\"\"Type all text at once instead of character by character\"\"\" full_text = \"\".join(text_chunks) type_text(full_text) # Cache common UI states screenshot_cache = {} def cached_screenshot_analysis(screenshot_hash): if screenshot_hash in screenshot_cache: return screenshot_cache[screenshot_hash] # ... analysis logic ``` **Speed vs. Accuracy Tradeoffs:** - Lower resolution = faster but less accurate clicking - Fewer verification screenshots = faster but more failures - Reduced delays = faster but more race conditions Most users find 70% accuracy at 2x speed better than 90% accuracy at 1x speed for repetitive tasks.

Currently viewing the AI version

Switch to human version

Anthropic Claude Computer Use: AI-Optimized Troubleshooting Guide

Configuration Requirements

Essential Settings That Work in Production

Display Resolution: 1280x800 (CRITICAL - higher resolutions cause pixel calculation errors)
Container Memory: 4GB minimum (default limits cause OOMKilled exits with code 137)
API Version: anthropic-beta: computer-use-2025-01-24
Model: claude-3-5-sonnet-20250109 (latest Computer Use model)
VNC Quality: quality=9, compression=0 for better screenshot analysis

Docker Configuration

environment:
  - DISPLAY_WIDTH=1280
  - DISPLAY_HEIGHT=800
  - COLOR_DEPTH=24
  - VNC_RESIZE=scale
  - VNC_QUALITY=9
  - VNC_COMPRESSION=0
services:
  computer-use:
    mem_limit: 4g
    memswap_limit: 4g
    ports:
      - "8081:8080"  # Avoid port 8080 conflicts

Critical Failure Modes

Screenshot Death Spiral (Most Common Production Killer)

Symptom: 500+ identical screenshots, API costs spike to $500+ per day
Root Cause: Claude stuck clicking non-responsive UI elements
Detection: More than 5 identical coordinates in sequence
Prevention:

max_screenshots_per_hour = 200  # ~$4/hour limit
daily_limit = 50  # Emergency brake at $50/day

Container Memory Exhaustion

Symptom: Container exits code 137 (OOMKilled)
Frequency: Occurs within 2-4 hours under normal load
Impact: All automation stops, requires manual restart
Prevention: 4GB memory limit, monitor at 90% threshold

Authentication Loops

Symptom: Repeated "authentication_error" despite valid API key
Common Causes:

API key contains spaces/newlines (copy-paste error)
Missing beta header: anthropic-beta: computer-use-2025-01-24
Account lacks Computer Use beta access

Click Coordinate Drift

Symptom: Claude reports successful clicks but UI doesn't respond
Root Cause: Resolution mismatch between container and Claude's expectations
Solution: Force exact resolution with xrandr --output VNC-0 --mode 1280x800

Resource Requirements

Time Investment

Initial Setup: 4-6 hours for stable configuration
Weekly Maintenance: 2 hours (log analysis, updates, monitoring)
Emergency Recovery: 30 minutes to 2 hours depending on failure type
Debugging Sessions: 2-8 hours when things break unexpectedly

Expertise Requirements

Docker: Intermediate (container management, networking, troubleshooting)
Linux/X11: Basic (display forwarding, VNC configuration)
API Integration: Basic (HTTP requests, authentication, error handling)
Monitoring: Intermediate (Prometheus, Grafana, log analysis)

Financial Costs

Normal Usage: $15-50/day for moderate automation
Loop Scenarios: $500-1500/day (emergency circuit breakers essential)
Infrastructure: $20-100/month for monitoring and hosting
Failure Recovery: $200-800 in wasted API calls during debugging

Performance Thresholds

Screenshot Processing

Acceptable: 1-3 seconds per screenshot
Warning: 5+ seconds indicates resolution/compression issues
Critical: 10+ seconds means infrastructure problems

Success Rates

Production Minimum: 70% task completion rate
Good Performance: 85%+ success rate
Excellent: 90%+ (rare, requires careful UI design)

API Limits

Rate Limits: 100 requests/minute (burst), 1000/hour (sustained)
File Size: 100MB maximum per image upload
Cost Scaling: ~$0.0045 per screenshot (varies by model)

Critical Warnings

What Official Documentation Doesn't Tell You

Windows Compatibility Issues

WSL2 Integration: Breaks constantly with Docker Desktop 4.24+
X11 Forwarding: More broken than functional on Windows
Recommendation: Use Linux or macOS for production deployments

Corporate Environment Blockers

Proxy/Firewall: Blocks api.anthropic.com (obviously)
SSL Inspection: Breaks API authentication
DNS Redirects: Route Anthropic to security scanners
Multi-factor Auth: Claude cannot handle SMS/hardware tokens

Hidden Infrastructure Dependencies

Port Conflicts: 8080 commonly used by Jupyter/Django
Memory Pressure: VNC + Browser + AI = 4GB+ requirement
Display Drivers: Different behavior across GPU vendors
Container Networking: Docker Desktop networking fragile on some systems

Breaking Points

UI Complexity: >10 step workflows have <50% reliability
Dynamic Content: JavaScript-heavy SPAs cause coordinate drift
Modal Dialogs: Claude cannot see through popup overlays
Session Timeouts: Corporate SSO expires every 30 minutes

Operational Intelligence

Comparative Difficulty Assessment

Easier than: Traditional Selenium WebDriver setup
Harder than: Simple API integrations
Similar complexity to: Multi-container Docker applications
More fragile than: Traditional RPA tools (UiPath, Automation Anywhere)

Community and Support Quality

Official Support: Minimal, mostly refers to documentation
Community: Active Discord but responses inconsistent
GitHub Issues: Primary source for real-world solutions
Documentation: Basic setup only, no production troubleshooting

Migration Pain Points

Version Updates: Breaking changes in tool API format
Model Changes: Different screenshot analysis behavior between Claude versions
Infrastructure: No automated migration tools, manual reconfiguration required

Decision Criteria

When Computer Use Is Worth It

Desktop Applications: Native apps without API access
Legacy Systems: No modern automation options
Visual Verification: When you need to see what the user sees
Rapid Prototyping: Quick proof-of-concept automation

When to Choose Alternatives

Web Applications: Playwright/Selenium more reliable and faster
API Available: Direct API integration always preferred
High Volume: Cost per action too high for bulk operations
Mission Critical: Traditional RPA more stable for production

Cost-Benefit Analysis

Break-even Point: Tasks taking >2 hours manually
Cost Scaling: Linear with screenshot frequency
Hidden Costs: Monitoring, maintenance, failure recovery time
ROI Threshold: 10x time savings needed to justify complexity

Emergency Procedures

Immediate Actions (< 5 minutes)

Stop containers: docker stop computer-use
Check API spending: Monitor for cost spikes
Disable API key if costs exploding

Recovery Checklist (< 30 minutes)

Check container logs: docker logs computer-use --tail 100
Verify system resources: CPU, memory, disk space
Fresh container from known-good image
Test simple task before resuming automation

Circuit Breaker Implementation

class CostCircuitBreaker:
    def __init__(self, daily_limit=50):
        self.daily_limit = daily_limit

    def check_spend(self, action_cost):
        if self.daily_spend + action_cost > self.daily_limit:
            raise Exception(f"Daily cost limit ${self.daily_limit} exceeded")

Monitoring Requirements

Essential Metrics

API Costs: Track per hour, alert at $20/hour
Success Rates: Alert below 70% completion
Container Health: Memory, CPU, restart count
Screenshot Frequency: Detect infinite loops

Alert Thresholds

High API Spend: >$20/hour (indicates loops)
Low Success Rate: <70% (UI changes or infrastructure issues)
Container Restarts: >3 per hour (unstable configuration)
Memory Usage: >90% (preemptive restart needed)

Workarounds for Known Issues

Screenshot Quality Problems

Blurry Images: Check DPI scaling, force 24-bit color depth
Partial Captures: Verify X11 display configuration
Wrong Colors: Container color mapping issues, restart VNC

Authentication Challenges

Corporate SSO: Pre-authenticate sessions, implement session keep-alive
MFA/CAPTCHA: Human handoff points, pause automation for intervention
Session Expiry: Monitor for "Sign In" text, trigger re-authentication

Performance Optimization

Reduce Resolution: 800x600 for speed vs 1280x800 for accuracy
Batch Operations: Type full text instead of character-by-character
Cache Analysis: Store screenshot analysis results for repeated UI states

This technical reference provides structured, actionable intelligence for successful Computer Use implementation while preserving all operational warnings and real-world constraints.

Useful Links for Further Investigation

Essential Debugging Resources & Tools

Link	Description
Anthropic Computer Use Documentation	Covers basic setup but useless for the real problems. When shit breaks at 3am, you'll be on Stack Overflow instead.
Anthropic API Error Reference	Complete list of API error codes and their meanings. Critical for debugging authentication and rate limiting issues. Bookmark this - you'll reference it constantly.
Computer Use GitHub Repository	The only working reference implementation. Issues section contains real-world problems and community solutions. Check the issues tab first - most "bugs" are actually configuration problems someone else already solved.
Anthropic Discord Community	Active support community where Anthropic staff occasionally respond. Good for asking specific technical questions and finding others with similar problems.
Docker Desktop Troubleshooting Guide	Official Docker troubleshooting covers most container startup issues. The "Reset to factory defaults" option fixes 80% of mysterious Docker problems.
Docker Container Debugging Handbook	Practical guide for diagnosing container issues. Covers memory problems, networking failures, and performance debugging.
WSL2 Docker Integration Guide	Essential if you're on Windows. WSL2 integration breaks constantly and this guide has most of the fixes. Keep it bookmarked.
X11 Forwarding Tutorial	GUI applications in Docker containers require X11 forwarding. This guide explains how to set it up correctly across different operating systems.
Prometheus Docker Monitoring	Set up proper monitoring for your Computer Use deployment. Track container health, resource usage, and API costs in real-time.
Grafana Dashboards for Docker	Pre-built dashboards for monitoring Docker containers. Search for "Docker Container" to find dashboards that track memory, CPU, and restart counts.
Docker Stats and Logging	Built-in Docker monitoring commands. docker stats and docker logs are your first debugging tools when things go wrong.
Anthropic API Console	Monitor your API usage and spending in real-time. Set up billing alerts here to prevent cost explosions from runaway screenshot loops.
AWS CloudWatch Billing Alerts	If you're hosting on AWS, set up billing alerts to catch unexpected cost spikes. Computer Use can rack up hundreds in API costs quickly.
API Rate Limiting Best Practices	Understanding Anthropic's rate limits prevents authentication errors. Implement proper backoff strategies to avoid hitting limits.
Postman for API Testing	Test Anthropic API calls directly to isolate whether problems are in your code or the API. Essential for debugging authentication and request format issues.
VNC Viewer Tools	Connect directly to your Computer Use container's desktop. Critical for seeing what Claude actually sees and debugging click coordinate problems.
Screenshot Comparison Tools	Compare screenshots to detect UI changes that break automation. Useful for understanding why previously working automations suddenly fail.
Docker Logs Analysis	Configure proper log collection and analysis. Computer Use generates tons of logs - you need tools to find the useful information.
Selenium WebDriver Documentation	For when Computer Use is overkill and you just need web browser automation. More reliable but less flexible than Computer Use.
Playwright Documentation	Modern browser automation that's faster and more reliable than Computer Use for web-only tasks. Consider this before implementing Computer Use.
UiPath Studio Community	Traditional RPA that's more reliable than Computer Use but requires much more setup. Good for comparing capabilities and costs.
Computer Use Security Research	Independent security analysis showing prompt injection vulnerabilities. Essential reading before production deployment.
Container Security Best Practices	Secure your Computer Use deployment properly. Computer Use has access to your desktop - security is critical.
Prompt Injection Mitigation	Understanding and preventing prompt injection attacks that can compromise Computer Use automation.
Hacker News - Claude Discussions	Active community discussing Computer Use implementations. Search for "Computer Use" to find real deployment horror stories and occasional solutions. Pro tip: Sort by "New" to find recent issues.
Stack Overflow - Claude Computer Use	Technical Q&A for specific implementation problems. Good source for troubleshooting specific error messages and code issues. Warning: Half the answers are from 2023 and broken now - always check the fucking date.
GitHub Issues - Real Problems	Browse issues in the official repository to see what problems other developers are facing. Often contains solutions not found in documentation.
Docker Emergency Commands	Quick reference for emergency container management: stop, restart, remove, and rebuild commands when things go wrong.
System Resource Monitoring	When Computer Use kills your system resources, you need to quickly identify what's consuming memory, CPU, or disk space.
Anthropic Status Page	Check if your Computer Use problems are actually Anthropic service outages. Don't debug for hours if the API is down.
Docker Community Forum	Search for Docker-specific issues and container troubleshooting. Often has solutions for mysterious container startup problems.

43%

Recommendations combine user behavior, content similarity, research intelligence, and SEO optimization