Praison AI

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.

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],
)

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

Programming Agent

📋 Code Request

🤖 Agent

🧠 Code Tools

✅ Working Code

Code development agent with execution, analysis, and shell tools.

Quick Start

  1. Simple Usage

    Attach code tools and ask for a script.

    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],
)

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

    Enable reflection so the agent self-checks its output before returning.

    python
    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

Diagram
Code ToolsAgentUserCode ToolsAgentUser“Write a fibonacci script”execute_code / analyze_codeOutput, errors, analysisWorking solution

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

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

Run — Python

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

bash
praisonai "Write a Python function to sort a list"

Run — agents.yaml

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
bash
praisonai agents.yaml

Serve API

python
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)
bash
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

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

Run — Python

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

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

Run — agents.yaml

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
bash
praisonai agents.yaml --verbose

Serve API

python
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)
bash
curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Write sorting code", "session_id": "code-001"}'

Monitor / Verify

bash
praisonai "test code" --verbose

Cleanup

bash
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

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

Card

The dedicated CodeAgent class with sandboxed execution.

 Card

Analyze data files with a data-focused agent.