AWE (Autonomous Workflow Engine)

AWE is an autonomous execution system that transforms high-level goals into structured, observable, and repeatable workflows. It decomposes intent into discrete steps, executes them programmatically, and exposes real-time progress through a directed execution graph.

The system is designed for engineers building, evaluating, or demonstrating agentic systems where transparency, determinism, and architectural clarity matter as much as autonomy itself.

Table of Contents

• About
• System Overview
• Architecture
• Project Structure
• Execution Model
• API Overview
• Frontend
• Local Development
• Deployment
• Configuration
• Design Philosophy
• License

About

AWE provides an execution substrate for autonomous reasoning and task orchestration. Users submit a single high-level objective, and AWE expands that objective into an explicit execution plan represented as a Directed Acyclic Graph (DAG). Each node in the graph corresponds to a concrete unit of work with well-defined inputs, outputs, and lifecycle state.

The platform emphasizes three core principles:

• Explicit Structure
  All reasoning and execution is materialized as graph nodes and edges. Nothing is implicit, hidden, or transient.

  

• Live Observability
  Execution state is streamed in real time, enabling users to inspect progress, dependencies, failures, and recovery paths as they occur.

  

• Deterministic Control Surfaces
  Every execution step is addressable, restartable, and auditable. The system is designed to support both experimentation and production-grade workflows.

  

AWE is suitable for technical demonstrations, internal tooling, research environments, and systems engineering interviews where architectural clarity and execution transparency are critical.

System Overview

At a high level, AWE consists of three layers:

• Execution Engine
  Responsible for goal decomposition, task scheduling, and lifecycle management.

• API and Realtime Layer
  Exposes REST and WebSocket interfaces for submitting goals, streaming execution events, and querying system state.

• Client Interface
  A frontend that visualizes the execution DAG, task states, and live progress.

All components are modular and designed for extension.

Architecture

Backend

The backend is built on FastAPI and provides both HTTP and WebSocket interfaces.

Core responsibilities include:

• Accepting high-level goals
• Decomposing goals into executable steps
• Constructing and managing the execution DAG
• Running tasks asynchronously
• Streaming execution updates to connected clients

Key characteristics include:

• Asynchronous, non-blocking execution model
• Clear separation between orchestration, execution, and transport layers
• Designed for stateless API deployment with externalized state where needed

Frontend

The frontend is a React and Vite application focused on execution transparency.

Responsibilities include:

• Submitting goals to the backend
• Visualizing the execution DAG
• Displaying live task state transitions
• Providing minimal but precise control surfaces

The frontend assumes no privileged knowledge of execution logic. All state is derived from backend APIs and realtime streams.

Overall,

Frontend (React + Vite)
        
        ↓ REST / WebSocket
        
Backend API (FastAPI)
        
        ↓ Task orchestration
        
Execution Engine
        
        ↓ State persistence
        
Vector / State Store

Project Structure

awe/
├── backend/                  # Backend service
│   ├── requirements.txt      # Python dependencies
│   ├── runtime.txt           # Python runtime version
│   ├── start.sh              # Service startup script
│   │
│   └── app/
│       ├── main.py           # FastAPI application entrypoint
│       ├── api.py            # HTTP API routes
│       ├── ws_manager.py     # WebSocket connection handling
│       ├── config.py         # Environment and app configuration
│       │
│       ├── agent/            # Execution engine and agent logic
│       │   ├── planner.py    # Goal decomposition and planning
│       │   ├── executor.py   # Task execution and scheduling
│       │   ├── graph_state.py# DAG state and lifecycle tracking
│       │   ├── memory.py     # Execution memory and state persistence
│       │   ├── models.py     # Internal data models
│       │   └── tools/        # Agent tool interfaces
│       │       ├── browser_tool.py
│       │       ├── file_tool.py
│       │       └── http_tool.py
│       │
│       └── sandbox/          # Isolated execution environment
│           ├── Dockerfile
│           └── runner.py
│
├── frontend/                 # Frontend client
│   ├── index.html
│   ├── package.json
│   ├── package-lock.json
│   ├── vite.config.mjs
│   ├── tsconfig.json
│   ├── tailwind.config.cjs
│   ├── postcss.config.cjs
│   ├── img1.png
│   ├── img2.png
│   ├── img3.png
│   ├── img4.png
│   │
│   └── src/
│       ├── main.tsx          # Frontend entrypoint
│       ├── App.tsx           # Root application component
│       ├── config.ts         # Frontend configuration
│       ├── styles/
│       │   └── tailwind.css
│       └── components/       # UI components
│           ├── GraphView.tsx # DAG visualization
│           ├── TaskConsole.tsx
│           ├── WsClient.ts
│           └── Logo.tsx
│
├── License
├── .gitignore
├── railway.toml              # Deployment configuration
└── README.md

Execution Model

1. A user submits a goal via the API.
2. The system decomposes the goal into a graph of dependent tasks.
3. Tasks are scheduled and executed asynchronously.
4. Each task transitions through well-defined states such as pending, running, completed, or failed.
5. State changes are streamed to clients in real time.
6. The full execution graph remains inspectable after completion.

This model ensures that autonomy never comes at the cost of debuggability or control.

API Overview

Base URL

/

Health check endpoint returning service status.

Submit a Goal

POST /api/run

Request

{
  "goal": "High level objective to execute"
}

Response

{
  "run_id": "unique-execution-id"
}

Realtime Updates

WS /ws

Streams execution events including:

• Task creation
• State transitions
• Execution output
• Failure and retry signals

Frontend

The frontend is a React application built with Vite.

Responsibilities include:

• Goal submission
• Real-time DAG visualization
• Execution history browsing
• Live status updates via WebSockets

The frontend is intentionally decoupled from backend implementation details and communicates exclusively through defined APIs.

Local Development

Prerequisites

• Python 3.11
• Node.js 18+
• pip
• npm or pnpm

Backend

cd backend/app
pip install -r requirements.txt
python -m uvicorn app.main:app --reload

Backend runs on http://localhost:8000.

Frontend

cd frontend
npm install
npm run dev

Frontend runs on http://localhost:5173.

Deployment

AWE is designed to deploy cleanly as two independent services.

Backend

• Stateless FastAPI service
• Requires environment variables for configuration
• Compatible with Render, Railway, Fly.io, and similar platforms

Key requirements:

• Correct Python runtime version
• Requirements file located at the backend root used by the platform
• Explicit CORS configuration when frontend and backend are on different domains

Frontend

• Static build output
• Can be deployed to any static hosting provider
• Requires a single environment variable pointing to the backend API base URL

Configuration

The system is configured entirely through environment variables.

For Example,

APP_HOST=0.0.0.0
APP_PORT=8000

Additional service integrations can be enabled without modifying core execution logic.

Design Philosophy

AWE is built around the belief that autonomous systems should be:

• Inspectable by default
• Deterministic where possible
• Observable at every layer
• Architected with clear boundaries

The project favors explicit data flow, explicit state transitions, and explicit interfaces over opaque abstractions.

License

AWE is licensed under the MIT License.