Introduction
In this tutorial, you'll learn how to create a simple autonomous task execution system similar to xAI's new /goal feature in Grok Build. This system will plan, execute, and verify multi-step coding tasks without human intervention. We'll build a basic framework that demonstrates the core concepts behind autonomous agents that can handle complex workflows.
Prerequisites
To follow this tutorial, you'll need:
- Basic understanding of Python programming
- Python 3.7 or higher installed on your system
- Some familiarity with command-line tools
Step-by-Step Instructions
Step 1: Set Up Your Development Environment
Creating a Project Directory
First, create a new directory for our autonomous task executor project:
mkdir autonomous_task_executor
cd autonomous_task_executorThis creates a clean workspace for our project files.
Installing Required Libraries
We'll need the openai library to interact with AI models, and python-dotenv to manage environment variables:
pip install openai python-dotenvThis installs the necessary packages for working with AI APIs and managing configuration.
Step 2: Create Your Configuration File
Setting Up Environment Variables
Create a file named .env in your project directory:
touch .envAdd the following content to your .env file:
OPENAI_API_KEY=your_openai_api_key_here
OPENAI_MODEL=gpt-4Important: Replace your_openai_api_key_here with your actual OpenAI API key. You can get one from the OpenAI platform.
Step 3: Initialize the Main Executor Class
Creating the Core Executor
Create a file named task_executor.py:
touch task_executor.pyOpen the file and add the following code:
import os
import time
from openai import OpenAI
from dotenv import load_dotenv
# Load environment variables
load_dotenv()
# Initialize OpenAI client
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
class AutonomousTaskExecutor:
def __init__(self):
self.model = os.getenv('OPENAI_MODEL')
self.current_task = None
self.execution_log = []
def plan_task(self, objective):
"""Plan how to execute the objective"""
prompt = f"""
You are an autonomous task planning agent. Plan how to complete the following objective:
{objective}
Provide a step-by-step plan with clear, executable actions. Return only the plan in JSON format with a 'steps' array.
"""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "You are a helpful assistant that creates detailed execution plans."},
{"role": "user", "content": prompt}
],
temperature=0.5
)
return response.choices[0].message.content
def execute_step(self, step_description):
"""Execute a single step of the plan"""
prompt = f"""
You are an autonomous execution agent. Execute the following step:
{step_description}
Provide a brief status update of your progress. If the step is complete, indicate so.
"""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "You are a helpful assistant that executes tasks step by step."},
{"role": "user", "content": prompt}
],
temperature=0.3
)
return response.choices[0].message.content
def verify_result(self, step_result, objective):
"""Verify if the step result meets the objective"""
prompt = f"""
You are a verification agent. Check if the following step result meets the objective:
Objective: {objective}
Step Result: {step_result}
Respond with either 'VERIFIED' if the result meets the objective, or 'NEEDS_REVISION' if it doesn't.
"""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "You are a helpful assistant that verifies task completion."},
{"role": "user", "content": prompt}
],
temperature=0.1
)
return response.choices[0].message.contentThis creates the core class that will handle planning, executing, and verifying tasks. Each method represents a key phase of autonomous execution.
Step 4: Add the Main Execution Loop
Implementing the Autonomous Workflow
Add the following methods to your task_executor.py file:
def execute_objective(self, objective):
"""Execute an entire objective from planning to completion"""
print(f"Starting execution of objective: {objective}")
self.current_task = objective
self.execution_log = []
# Step 1: Plan the task
print("\n--- Planning Task ---")
plan_response = self.plan_task(objective)
print(f"Plan: {plan_response}")
self.execution_log.append({"phase": "planning", "result": plan_response})
# Step 2: Execute each step
print("\n--- Executing Steps ---")
steps = self.parse_plan(plan_response)
for i, step in enumerate(steps):
print(f"\nExecuting step {i+1}: {step}")
step_result = self.execute_step(step)
print(f"Result: {step_result}")
# Step 3: Verify the result
print("\n--- Verifying Result ---")
verification = self.verify_result(step_result, objective)
print(f"Verification: {verification}")
self.execution_log.append({
"phase": "execution",
"step": i+1,
"description": step,
"result": step_result,
"verification": verification
})
if "NEEDS_REVISION" in verification:
print("\nStep needs revision. Replanning...")
# In a real implementation, you'd add logic to revise and retry
break
print("\n--- Task Execution Complete ---")
return self.execution_log
def parse_plan(self, plan_response):
"""Parse the plan response to extract individual steps"""
# This is a simplified parser - in practice, you'd want more robust parsing
try:
import json
plan_data = json.loads(plan_response)
return plan_data.get('steps', [])
except:
# If JSON parsing fails, return the response as a single step
return [plan_response]This implementation creates the complete workflow for autonomous task execution, including planning, execution, and verification phases.
Step 5: Create a Simple Test Script
Testing Your Executor
Create a file named main.py:
touch main.pyAdd the following code to test your executor:
from task_executor import AutonomousTaskExecutor
# Create executor instance
evaluator = AutonomousTaskExecutor()
# Define a simple objective
objective = "Create a Python script that calculates the factorial of numbers 1 through 5 and displays the results."
# Execute the objective
log = evaluator.execute_objective(objective)
# Print the execution log
print("\n--- Execution Log ---")
for entry in log:
print(entry)This script tests your autonomous executor with a simple coding task.
Step 6: Run Your Autonomous Executor
Executing Your Code
Run your test script:
python main.pyWatch as your system plans, executes, and verifies the task. You'll see output showing each phase of execution.
Summary
In this tutorial, you've built a basic autonomous task execution system inspired by xAI's /goal feature in Grok Build. You created a system that can plan complex tasks, execute them step-by-step, and verify results automatically. While this is a simplified implementation, it demonstrates the core concepts behind autonomous AI agents that can handle multi-step coding tasks without human intervention.
The key components you learned about include:
- Planning phase: Breaking down objectives into executable steps
- Execution phase: Carrying out individual steps
- Verification phase: Ensuring results meet the original objective
- Integration with AI APIs for intelligent decision-making
This foundation can be expanded with more sophisticated parsing, error handling, and retry mechanisms to create more robust autonomous systems.
