AWM v0.2.0 — Autonomous Workflow Model

Autonomous Workflow Model (AWM) is a prompt- and schema-driven multi-agent workflow system designed to run inside ChatGPT. It orchestrates multiple reasoning passes to accomplish complex tasks through a structured, multi-step process.

Overview

AWM transforms ChatGPT into an autonomous workflow engine by implementing a multi-agent system consisting of:

• Planner: Creates a step-by-step plan based on the task envelope
• Reviewer: Validates and refines the plan
• Executor: Executes the plan and produces the final output
• Knowledge: Manages context and persistent information

All execution occurs within ChatGPT, with this repository serving as the source of truth for prompts, schemas, and knowledge.

Architecture

┌─────────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│   User Input    │───▶│   Planner    │───▶│   Reviewer   │───▶│   Executor   │
│ (Task Envelope) │    │ (Plan)       │    │ (Validation) │    │ (Execution)  │
└─────────────────┘    └──────────────┘    └──────────────┘    └──────────────┘

Core Components

Prompts

• persona.md: Defines AWM's identity and behavior
• planner.md: Orchestrates the planning phase
• reviewer.md: Validates plans and outputs
• execution.md: Executes planned steps
• meta.md: Handles meta-level workflow decisions
• knowledge.md: Manages context and memory

Schemas

• task_protocol.json: Defines the structure of AWM task envelopes
• agents.json: Schema for agent definitions and capabilities

Knowledge Base

• glossary.json: Definitions of AWM-specific terms
• memory.json: Persistent memory for the system

Configuration

• awm_runner.json: Path mappings and configuration settings

Task Protocol

AWM operates using structured task envelopes with the following format:

{
  "task_type": "awm_task | update_core",
  "task": "Short natural language description of the goal",
  "context": "Optional additional context",
  "inputs": {},
  "constraints": {},
  "output_format": "markdown | json | text",
  "success_criteria": []
}

Task Types

1. Normal Tasks (awm_task): Produce artifacts like documents, code, designs, or analyses
2. Core Updates (update_core): Update AWM core files with suggested git snippets

File Structure

awm/
├── config/
│   └── awm_runner.json          # Configuration and path mappings
├── knowledge/
│   ├── glossary.json            # Term definitions
│   └── memory.json              # Persistent memory
├── prompts/
│   ├── execution.md             # Execution agent prompt
│   ├── knowledge.md             # Knowledge agent prompt
│   ├── meta.md                  # Meta agent prompt
│   ├── persona.md               # System persona
│   ├── planner.md               # Planning agent prompt
│   └── reviewer.md              # Review agent prompt
├── schema/
│   ├── agents.json              # Agent schema
│   └── task_protocol.json       # Task envelope schema
└── version.json                 # Version information

Usage

Basic Workflow

1. Prepare an AWM task envelope describing your goal
2. Provide the envelope to ChatGPT running the AWM system
3. ChatGPT loads prompts and schemas from this repository
4. AWM executes the Planner → Reviewer → Executor workflow
5. Receive the final output artifact

Example Task Envelope

{
  "task_type": "awm_task",
  "task": "Create a technical specification document for a new feature",
  "context": "For internal team review, focusing on scalability and maintainability",
  "inputs": {
    "feature_name": "User Authentication System",
    "requirements": ["OAuth integration", "Multi-factor authentication"]
  },
  "constraints": {
    "length": "2-3 pages",
    "style": "technical documentation format"
  },
  "output_format": "markdown",
  "success_criteria": [
    "Includes architecture diagram",
    "Covers security considerations",
    "Defines API endpoints"
  ]
}

Core Updates

AWM can update its own core files through special update_core tasks. When this happens:

1. AWM proposes new file contents
2. Generates a local git snippet for the changes
3. You apply and push the changes to this repository
4. Future runs use the updated core

Key Principles

• Direct and Precise: Technical accuracy over unnecessary verbosity
• Self-Contained: All necessary information lives in this repository
• Version Controlled: Changes are tracked via git for reproducibility
• Modular: Clear separation between prompts, schemas, and knowledge
• Extensible: Easy to add new agents or modify existing behaviors

Version Information

Current version: 0.2.0

This version implements a ChatGPT-native workflow with all prompts, schemas, and knowledge stored in this repository. Execution occurs entirely within ChatGPT, with git and GitHub used only for storing and versioning the AWM core files.

Contributing

To contribute to AWM:

1. Fork this repository
2. Make changes to prompts, schemas, or knowledge files
3. Test with sample task envelopes
4. Submit pull request with clear rationale for changes

License

See LICENSE file for licensing information.