Autonomous Work Mesh (AWM) — v1.0.4

Status: v1.0.4 RELEASE CANDIDATE

AWM is a capability-routed, artifact-first autonomous work mesh with full goal lifecycle support and LLM plugin architecture.

What’s New in v1.0

• ✅ Complete Goal Lifecycle: Formulate → Decompose → Execute → Evaluate
• ✅ LLM Plugin Architecture: Pluggable providers (deterministic, OpenAI, local)
• ✅ Replanning: Automatic repair task insertion on failures
• ✅ Progress Tracking: Real-time goal progress monitoring
• ✅ Production-Ready: 9/9 tests passing, comprehensive docs

Quickstart

# Run a simple task
python -m orchestrator run examples/tasks/example_task.json

# Create and execute a goal
python -m orchestrator goal formulate --objective "Improve API response time" --out goal.json
python -m orchestrator goal run goal.json --outdir outputs

Architecture

┌─────────────────────────────────────────────────────────────┐
│                         AWM v1.0                             │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────┐    ┌──────────────────┐    ┌──────────────┐  │
│  │  Router  │───▶│     Agents       │───▶│   Executors  │  │
│  └──────────┘    └──────────────────┘    └──────────────┘  │
│        │                                               │    │
│        ▼                                               ▼    │
│  ┌───────────────────────────────────────────────────────┐  │
│  │              Goal Lifecycle (Phase 3)                  │  │
│  │   formulate → decompose → execute → evaluate → track   │  │
│  └───────────────────────────────────────────────────────┘  │
│                           │                                 │
│                           ▼                                 │
│  ┌───────────────────────────────────────────────────────┐  │
│  │              LLM Plugin Architecture (Phase 4)          │  │
│  │   deterministic │ OpenAI (stub) │ local (stub)         │  │
│  └───────────────────────────────────────────────────────┘  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Features

Core Capabilities

• Capability-Based Routing: Agents selected by capability matching
• Artifact-First Design: All outputs conform to JSON schemas
• State Machine: Explicit task lifecycle (created → archived)
• Learning Loop: Metrics collection + meta analysis (Phase 2)

Goal System (Phase 3)

• Goal Formulation: Natural language → structured goals
• Task Graph Decomposition: Automatic dependency-aware task generation
• Progress Tracking: Real-time completion percentage
• Evaluation: Deterministic success criteria assessment
• Replanning: Automatic repair on failure with configurable policies

LLM Integration (Phase 4)

• Plugin Architecture: Swappable LLM providers
• Built-in Providers:
  • deterministic: No external calls (default, production-ready)
  • openai: Stub ready for SDK wiring
  • local: Stub for Ollama/lm-studio
• Integration Points: Formulator, Manager, Evaluator, Replaner

Directory Structure

awm_v1.0/
├── schema/                    # JSON Schemas
│   ├── agents.json           # Agent definitions
│   ├── routing_rules.json    # Capability routing
│   ├── goal_schema.json      # Goal structure
│   ├── task_graph_schema.json # Task dependencies
│   └── *.schema.json
├── orchestrator/             # Core engine
│   ├── router.py            # Agent routing
│   ├── state_manager.py     # Task lifecycle
│   ├── goal_manager.py      # Goal lifecycle
│   ├── goal_formulator.py   # Goal creation
│   ├── evaluator.py         # Success evaluation
│   ├── replanner.py         # Failure recovery
│   ├── llm/                 # LLM plugin architecture
│   │   ├── provider.py     # Provider interface
│   │   ├── registry.py      # Plugin discovery
│   │   ├── deterministic.py # Built-in (no LLM)
│   │   ├── openai.py       # OpenAI stub
│   │   └── local.py        # Local LLM stub
│   └── *.py
├── prompts/                 # Prompt templates
├── knowledge/                # Memory store
│   ├── memory.json         # Task memory
│   └── goals.json          # Goal queue
├── docs/                    # Documentation
├── tests/                   # Test suite (9 tests)
├── examples/                # Example tasks
└── outputs/                 # Generated artifacts

CLI Reference

# Task execution
awm run <task.json>                    # Run single task
awm run <task.json> --outdir outputs   # Custom output dir

# Goal lifecycle
awm goal formulate --objective "..." --out goal.json   # Create goal
awm goal decompose goal.json --out graph.json         # Generate tasks
awm goal run goal.json --outdir outputs              # Execute goal
awm goal evaluate goal.json --tasks_dir outputs/tasks # Evaluate success
awm goal run_queue                                   # Run next from queue

# LLM providers
awm goal providers              # List available providers
awm --config awm.yaml run ...  # Use YAML config

Configuration

# config/awm.yaml (optional)
llm:
  provider: ${AWM_LLM_PROVIDER:-deterministic}
  providers:
    openai:
      api_key: ${OPENAI_API_KEY}
      model: gpt-4
    local:
      endpoint: http://localhost:8000/v1
  timeout: 60

goals:
  max_replans: 2
  critical_fail_policy: degrade

Goals and Task Graphs

Goal Structure

{
  "goal_id": "goal_improve_latency_001",
  "title": "Improve API Response Time",
  "objectives": [
    {"target": "p99_latency", "current": "450ms", "target_value": "270ms"}
  ],
  "success_criteria": ["All tasks completed"],
  "constraints": ["No breaking changes"],
  "priority": 75
}

Task Graph (Auto-Generated)

research → design → implement → test → validate → evaluate

Testing

# Run all tests
python -m pytest tests/ -v

# Expected output
# 9 passed in 0.12s

Documentation

Guide	Description
docs/user_guide.md	Getting started tutorial
docs/goal_lifecycle.md	Goal system deep dive
docs/cli_reference.md	Complete CLI reference
docs/developer_guide.md	Extension guide
docs/architecture.md	System architecture
docs/plugins.md	LLM provider development
docs/migration.md	Upgrade from v0.x

LLM Provider Development

from orchestrator.llm import LLMProvider, LLMMessage

class MyProvider(LLMProvider):
    name = "my_provider"
    
    def complete(self, messages, schema=None, temperature=0.3, max_tokens=2000):
        # Your implementation
        return LLMResponse(content="...", usage={}, model=self.name, raw={})
    
    def validate_config(self):
        return True
    
    def health_check(self):
        return True

Register via orchestrator/llm/registry.py or entry points.

Version History

Version	Date	Status
v0.3.0	2024-12	Phase 1: Basic execution
v0.4.0	2025-01	Phase 2: Learning loop
v0.45.0	2025-02-16	Phase 3: Goal scaffold
v1.0.4	2025-02-17	Phase 4: Production release

License

Unlicense (recommended for your libre tooling posture).

Credits

Built with OpenClaw autonomous agent framework.