Skip to main content
Write, run, and debug code with a single Agent equipped with execution and analysis tools. 
from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="You are a programming agent. Write and execute code.",
    tools=[execute_code, analyze_code],
)

agent.start("Write a Python script to calculate fibonacci numbers")
Code development agent with execution, analysis, and shell tools.
This page uses a plain Agent with code tools — ideal as a task-focused recipe. For the dedicated CodeAgent class with sandboxed generate/execute/review/refactor methods, see the Code Agent page.

​
Quick Start

1

Simple Usage

Attach code tools and ask for a script.
from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="You are a programming agent. Write and execute code.",
    tools=[execute_code, analyze_code],
)

agent.start("Write a Python script to calculate fibonacci numbers")
2

With Configuration

Enable reflection so the agent self-checks its output before returning.
from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="Write, execute, and verify code before returning it.",
    tools=[execute_code, analyze_code],
    memory=True,
    reflection=True,
)

agent.start("Write and test a quicksort implementation.")

​
How It Works

​
Simple

Agents: 1 — Single agent with code tools handles writing and executing code.

​
Workflow

  1. Receive code request
  2. Generate code
  3. Execute and test
  4. Return working solution

​
Setup

pip install praisonaiagents praisonai
export OPENAI_API_KEY="your-key"

​
Run — Python

from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="You are a programming agent. Write and execute code.",
    tools=[execute_code, analyze_code]
)

result = agent.start("Write a Python script to calculate fibonacci numbers")
print(result)

​
Run — CLI

praisonai "Write a Python function to sort a list"

​
Run — agents.yaml

framework: praisonai
topic: Code Development
roles:
  programmer:
    role: Software Developer
    goal: Write and execute code
    backstory: You are an expert programmer
    tools:
      - execute_code
      - analyze_code
    tasks:
      write_code:
        description: Write a Python script to calculate fibonacci numbers
        expected_output: Working Python code

praisonai agents.yaml

​
Serve API

from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="You are a programming agent.",
    tools=[execute_code, analyze_code]
)

agent.launch(port=8080)

curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Write a function to reverse a string"}'

​
Advanced Workflow (All Features)

Agents: 1 — Single agent with memory, persistence, structured output, and session resumability.

​
Workflow

  1. Initialize session for code project tracking
  2. Configure SQLite persistence for code history
  3. Generate and execute code with structured output
  4. Store code in memory for iterative development
  5. Resume session for code modifications

​
Setup

pip install praisonaiagents praisonai pydantic
export OPENAI_API_KEY="your-key"

​
Run — Python

from praisonaiagents import Agent, Task, AgentTeam, Session
from praisonaiagents.tools import execute_code, analyze_code
from pydantic import BaseModel

# Structured output schema
class CodeResult(BaseModel):
    language: str
    code: str
    output: str
    explanation: str

# Create session for project tracking
session = Session(session_id="code-001", user_id="user-1")

# Agent with memory and tools
agent = Agent(
    name="Programmer",
    instructions="Write, execute, and return structured code results.",
    tools=[execute_code, analyze_code],
    memory=True,
    reflection=True
)

# Task with structured output
task = Task(
    description="Write a Python script to calculate fibonacci numbers",
    expected_output="Structured code result",
    agent=agent,
    output_pydantic=CodeResult
)

# Run with SQLite persistence
agents = AgentTeam(
    agents=[agent],
    tasks=[task],
    memory=True
)

result = agents.start()
print(result)

# Resume later
session2 = Session(session_id="code-001", user_id="user-1")
history = session2.search_memory("fibonacci")

​
Run — CLI

praisonai "Write fibonacci code" --memory --verbose

​
Run — agents.yaml

framework: praisonai
topic: Code Development
memory: true
memory_config:
  provider: sqlite
  db_path: code.db
roles:
  programmer:
    role: Software Developer
    goal: Write and execute code with structured output
    backstory: You are an expert programmer
    tools:
      - execute_code
      - analyze_code
    memory: true
    tasks:
      write_code:
        description: Write a Python script to calculate fibonacci numbers
        expected_output: Structured code result
        output_json:
          language: string
          code: string
          output: string
          explanation: string

praisonai agents.yaml --verbose

​
Serve API

from praisonaiagents import Agent
from praisonaiagents.tools import execute_code, analyze_code

agent = Agent(
    name="Programmer",
    instructions="Write and execute code.",
    tools=[execute_code, analyze_code],
    memory=True
)

agent.launch(port=8080)

curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Write sorting code", "session_id": "code-001"}'

​
Monitor / Verify

praisonai "test code" --verbose

​
Cleanup

rm -f code.db

​
Features Demonstrated

FeatureImplementation
WorkflowMulti-step code development
DB PersistenceSQLite via memory_config
Observability--verbose flag
Toolsexecute_code, analyze_code
ResumabilitySession with session_id
Structured OutputPydantic CodeResult model

​
Best Practices

Attach execute_code so the agent runs its own output and catches errors before returning. Code that only looks right often fails on the first run.
Set reflection=True so the agent reviews and corrects its solution. This trades a few extra tokens for markedly higher first-try success on non-trivial code.
When you need process isolation, timeouts, and language restrictions, use the dedicated CodeAgent class instead of a plain Agent with tools.
If you switch to CodeAgent, keep sandbox=True in production. Executing model-generated code without isolation is a security risk.

The dedicated CodeAgent class with sandboxed execution.

Analyze data files with a data-focused agent.