Programming Agent

Learn how to create AI agents for code development, analysis, and execution.

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

Feature	Implementation
Workflow	Multi-step code development
DB Persistence	SQLite via memory_config
Observability	--verbose flag
Tools	execute_code, analyze_code
Resumability	Session with session_id
Structured Output	Pydantic CodeResult model

Best Practices

Let the agent execute, then verify

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.

Enable reflection for tricky tasks

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.

Prefer the CodeAgent for sandboxed workflows

When you need process isolation, timeouts, and language restrictions, use the dedicated CodeAgent class instead of a plain Agent with tools.

Never disable the sandbox on untrusted input

If you switch to CodeAgent, keep sandbox=True in production. Executing model-generated code without isolation is a security risk.

Related

The dedicated CodeAgent class with sandboxed execution.

Analyze data files with a data-focused agent.