> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Execution & Extension Systems

> Complete comparison of PraisonAI's 9 systems: Job Workflows, Agent Workflows, Hybrid Workflows, Recipes, Slash Commands, Tools, Skills, Plugins, and Hooks

PraisonAI has **9 distinct systems** across two categories: **Execution Systems** (things that run) and **Extension Systems** (things that extend agent capabilities).

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent

# Simplest path — Agent Workflow
agent = Agent(name="researcher", instructions="Research AI trends")
agent.start("Summarise the latest LLM papers")
```

The user picks a workflow or extension; each system attaches jobs, recipes, tools, or hooks to the same agent core.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Execution vs Extension"
        E1[Job Workflow] --> A[Agent]
        E2[Agent Workflow] --> A
        E3[Recipe] --> A
        X1[Tools] --> A
        X2[Skills] --> A
        X3[Plugins] --> A
        X4[Hooks] --> A
    end

    classDef agent fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef exec fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef ext fill:#10B981,stroke:#7C90A0,color:#fff

    class A agent
    class E1,E2,E3 exec
    class X1,X2,X3,X4 ext
```

## How It Works

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant Agent
    participant Feature as Execution & Extension 

    User->>Agent: Request
    Agent->>Feature: Process request
    Feature-->>Agent: Result    Agent-->>User: Response
```

## Quick Start

<Steps>
  <Step title="Run an agent workflow">
    The default execution path — one agent, one prompt:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent

    agent = Agent(name="researcher", instructions="Research AI trends")
    agent.start("Summarise the latest LLM papers")
    ```
  </Step>

  <Step title="Run a job workflow from YAML">
    Mix shell steps and agent steps in a deterministic pipeline:

    ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    type: job
    name: release
    steps:
      - name: Build
        run: uv build
      - name: Changelog
        agent:
          role: Technical Writer
          prompt: Generate changelog
          model: gpt-4o-mini
    ```

    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai workflow run release.yaml
    ```
  </Step>
</Steps>

## At a Glance

### Execution Systems

| System | CLI | What Runs | Deterministic | Needs API Key |
| - | - | - | :-: | :-: |
| **Job Workflows** | `praisonai workflow run` | Shell, Python, actions, agent steps | Mostly ✅ | Only for agent steps |
| **Agent Workflows** | `praisonai workflow run` | LLM agents collaborating | ❌ | ✅ |
| **Hybrid Workflows** | `praisonai workflow run` | Job + multi-agent steps | Mixed | ✅ |
| **Recipes** | `praisonai recipe run` | LLM agents + lifecycle | ❌ | ✅ |
| **Slash Commands** | `/cmd` in REPL | Handler functions | ✅ | ❌ |

### Extension Systems

| System | Scope | What It Provides |
| - | - | - |
| **Tools** | Per-agent | Callable functions (`@tool`, `BaseTool`) |
| **Skills** | Per-agent | Declarative expertise (`SKILL.md` + prompts) |
| **Plugins** | System-wide | Bundled tools + hooks + skills + recipes |
| **Hooks & Callbacks** | System-wide | Lifecycle interception and notification |

***

## Execution Systems

### 1. Job Workflows

Ordered step execution mixing deterministic automation and AI agent steps.

**Discriminator**: `type: job` in YAML | **Engine**: `JobWorkflowExecutor`

**Routing**: Honored by both the CLI (`praisonai workflow run ...`) and the programmatic wrapper (`AgentsGenerator.generate_crew_and_kickoff()` / `.agenerate_crew_and_kickoff()`). The sync path is now scope-isolated for every `process:` value — `generate_crew_and_kickoff()` wraps `adapter.run(...)` in `scoped_bridge()` for `sequential` and `hierarchical`; `_run_yaml_workflow` wraps `workflow.start(...)` in `scoped_bridge()` for `workflow`. A stuck coroutine in any one run cannot park the shared default loop for other tenants. See [Async Bridge → Per-run auto-scoping](/docs/features/async-bridge#per-run-auto-scoping-sequential-hierarchical-workflow).

**Deterministic steps**: `run:` (shell), `python:` (script), `script:` (inline Python), `action:` (custom/built-in)

**Agent-centric steps**: `agent:` (AI agent), `judge:` (quality gate), `approve:` (approval gate)

```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
type: job
name: smart-release
steps:
  - name: Build
    run: uv build
  - name: Generate changelog
    agent:
      role: Technical Writer
      prompt: Generate changelog
      model: gpt-4o-mini
    output_file: CHANGELOG.md
  - name: Quality check
    judge:
      input_file: CHANGELOG.md
      threshold: 8.0
      on_fail: warn
```

**Key features**: 3-tier action resolution, custom CLI flags, conditional steps, `--dry-run`, agent/judge/approve steps

<CardGroup cols={2}>
  <Card title="Job Workflows" icon="list-check" href="/docs/features/job-workflows">
    Step types, agent steps, flags, conditionals
  </Card>

  <Card title="Custom Actions" icon="puzzle-piece" href="/docs/features/custom-actions">
    YAML-defined, file-based, and built-in actions
  </Card>
</CardGroup>

***

### 2. Agent Workflows

LLM-powered agent pipelines — AI agents collaborate on tasks.

**Discriminator**: No `type` field (default) | **Engine**: Agent Workflow Engine

```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
topic: Research AI Trends
roles:
  researcher:
    role: AI Researcher
    goal: Find latest papers
    tools:
      - internet_search
```

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
praisonai workflow run research.yaml
```

**Key features**: Agents with roles/goals/backstories, tool integration, multi-agent collaboration, non-deterministic

<Card title="Agent Workflows" icon="robot" href="/docs/features/workflows">
  Agent definitions, tasks, process types
</Card>

***

### 2.5. Hybrid Workflows

Combines job workflow steps (deterministic + agent) with multi-agent collaboration steps.

**Discriminator**: `type: hybrid` in YAML | **Engine**: `HybridWorkflowExecutor`

**Routing**: Honored by both the CLI (`praisonai workflow run ...`) and the programmatic wrapper (`AgentsGenerator.generate_crew_and_kickoff()` / `.agenerate_crew_and_kickoff()`). The sync path is now scope-isolated for every `process:` value — `generate_crew_and_kickoff()` wraps `adapter.run(...)` in `scoped_bridge()` for `sequential` and `hierarchical`; `_run_yaml_workflow` wraps `workflow.start(...)` in `scoped_bridge()` for `workflow`. A stuck coroutine in any one run cannot park the shared default loop for other tenants. See [Async Bridge → Per-run auto-scoping](/docs/features/async-bridge#per-run-auto-scoping-sequential-hierarchical-workflow).

Supports all job workflow step types **plus**:

* `workflow:` — execute a named agent from the `agents:` block
* `parallel:` — run multiple sub-steps concurrently

```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
type: hybrid
agents:
  researcher:
    role: Research Analyst
    instructions: Provide concise findings
steps:
  - name: Setup
    run: echo "Starting..."
  - name: Research
    workflow:
      agent: researcher
      action: Research best practices
  - name: Parallel checks
    parallel:
      - run: echo "Lint passed"
      - run: echo "Tests passed"
```

<Card title="Hybrid Workflows" icon="shuffle" href="/docs/features/hybrid-workflows">
  Multi-agent + deterministic steps in one pipeline
</Card>

### 3. Recipes

Packaged, distributable agent workflows with full lifecycle management.

**CLI**: `praisonai recipe` (separate command group) | **Engine**: `recipe.run()`

**Discovery (5-tier)**: `$PRAISONAI_RECIPE_PATH` → `./recipes/` → `~/.praison/recipes/` → `agent_recipes` pip package → built-in

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
praisonai recipe run support-reply --input '{"ticket_id": "T-123"}'
praisonai recipe judge run-abc123 --yaml agents.yaml
praisonai recipe optimize my-recipe --iterations 5
praisonai recipe pack my-recipe
praisonai recipe publish my-recipe.praison
praisonai recipe serve my-recipe
```

**Key features**: `pack`/`publish`/`pull`/`install`, `judge`/`optimize`/`apply` lifecycle, policy packs, SBOM/audit, HTTP serving, trace replay

<Card title="Recipes" icon="book" href="/docs/features/modular-recipes">
  Recipe structure, lifecycle, governance
</Card>

***

### 4. Slash Commands

Interactive commands in the PraisonAI REPL. User types `/cmd` — no YAML, no CLI invocation outside REPL.

***

## Extension Systems

### 5. Tools

Functional actions that agents call to interact with the outside world.

**Scope**: Per-agent | **Discovery**: Lazy-loaded via `praisonaiagents.tools.registry.py` entry points

**Implementation options**:

* **Function-based**: `@tool` decorated functions
* **Class-based**: `BaseTool` or Pydantic classes for stateful operations
* **External packages**: Pip packages discovered via `entry_points` under the canonical `praisonai.tools` group. `praisonaiagents.tools` and `praisonai.tool_sources` are kept as deprecated one-cycle aliases (they still resolve, with a `DeprecationWarning` on first discovery).

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from praisonaiagents.tools import internet_search

agent = Agent(tools=[internet_search])
```

> **Key distinction**: Tools are **procedural** — Python code that does something.

<Card title="Tools Guide" icon="wrench" href="/docs/tools/tools">
  Built-in tools, custom tools, tool classes
</Card>

***

### 6. Skills

Declarative expertise modules — reusable prompts and knowledge.

**Scope**: Per-agent | **Standard**: Agent Skills (agentskills.io) | **CLI**: `praisonai skill list/install/validate`

```
.praison/skills/
├── code-review/
│   └── SKILL.md
├── seo-expert/
│   └── SKILL.md
```

> **Key distinction**: Skills are **declarative** — `SKILL.md` + prompt templates, not code.

Skills can be generated autonomously using the Identify-Scrape-Synthesize (ISS) pattern.

***

### 7. Plugins

System-wide extension bundles — the marketplace unit.

**Scope**: System-wide | **Manager**: `PluginManager` (global registry + discovery) | **Location**: `.praison/plugins/`, pip packages

A plugin can bundle:

* **Tools** — adds new agent actions
* **Skills** — adds agent expertise templates
* **Recipes** — adds pre-defined agent teams
* **Hooks** — adds logging, security, monitoring
* **Integrations** — connects to Slack, Telegram, APIs

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonai import plugins
plugins.enable("slack")
# or via env: PRAISONAI_PLUGINS=slack,logging
```

> **Key distinction**: Plugins are **containers** — they deliver tools, skills, hooks, and recipes as a single installable unit.

***

### 8. Hooks & Callbacks

Lifecycle interception (hooks) and notification (callbacks).

**Hooks** — middleware functions that can **modify** agent requests/responses:

| Category | Hooks |
| - | - |
| Lifecycle | `ON_INIT`, `ON_SHUTDOWN` |
| Agent | `BEFORE_AGENT`, `AFTER_AGENT` |
| LLM | `BEFORE_LLM`, `AFTER_LLM` |
| Tools | `BEFORE_TOOL`, `AFTER_TOOL` |
| Messages | `BEFORE_MESSAGE`, `AFTER_MESSAGE` |

**Use for**: Retries, caching, request modification, guardrails.

**Callbacks** — simple functions called **after** a Task completes. Cannot modify execution flow.

**Use for**: Logging, database updates, alerting.

***

## How They Relate

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
flowchart TD
    P["Plugin"] -->|bundles| T["Tools"]
    P -->|bundles| S["Skills"]
    P -->|bundles| R["Recipes"]
    P -->|bundles| H["Hooks"]
    R -->|contain| AW["Agent Workflows"]
    R -->|"add lifecycle"| LC["judge / optimize / serve"]
    AW -->|use| T
    AW -->|use| S
    JW["Job Workflows"] -.->|"same CLI, different engine"| AW
    SC["Slash Commands"] -.->|"REPL only"| AW
    
    style P fill:#8B5CF6,color:#fff
    style T fill:#10B981,color:#fff
    style S fill:#06B6D4,color:#fff
    style R fill:#F59E0B,color:#fff
    style H fill:#EF4444,color:#fff
    style JW fill:#10B981,color:#fff
    style AW fill:#6366F1,color:#fff
    style LC fill:#F59E0B,color:#fff
    style SC fill:#6B7280,color:#fff
```

***

## Master Comparison

### Identity & Scope

| | Job Workflows | Hybrid | Agent Workflows | Recipes | Tools | Skills | Plugins | Hooks |
| - | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: |
| **Type** | Execution | Execution | Execution | Execution | Extension | Extension | Extension | Extension |
| **AI-powered** | Optional | ✅ | ✅ | ✅ | N/A | N/A | N/A | N/A |
| **Scope** | Project-local | Project-local | Project-local | External | Per-agent | Per-agent | System-wide | System-wide |
| **Deterministic** | Mostly ✅ | Mixed | ❌ | ❌ | ✅ | N/A | ✅ | ✅ |

### Distribution & Lifecycle

| | Job Workflows | Agent Workflows | Recipes | Tools | Skills | Plugins |
| - | :-: | :-: | :-: | :-: | :-: | :-: |
| **Registry** | ❌ | ❌ | ✅ | ✅ (entry\_points) † | ❌ | ✅ (pip) † |
| **pack/publish** | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ (pip) |
| **judge/optimize** | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| **HTTP serve** | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| **SBOM/audit** | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| **Versioned** | ❌ | ❌ | ✅ | ✅ (pip) | ❌ | ✅ (pip) |

<Note>
  † **Built-ins win over entry-point plugins.** The Tools and Plugins registries subclass the base `PluginRegistry`, so since [PR #4176](https://github.com/MervinPraison/PraisonAI/pull/4176) an `entry_points` plugin whose name (case-insensitive) collides with a shipped built-in is skipped and the built-in is kept (a `DEBUG` line notes the collision). Runtime `register(...)` is the deliberate override path. See [Plugin Precedence](/docs/features/plugin-precedence).
</Note>

### Execution Model

| | Job Workflows | Hybrid | Agent Workflows | Recipes |
| - | :-: | :-: | :-: | :-: |
| **Dry-run** | ✅ | ✅ | ❌ | ✅ |
| **Agent steps** | ✅ `agent`, `judge`, `approve` | ✅ | ✅ (native) | ✅ (native) |
| **Multi-agent** | ❌ | ✅ `workflow:`, `parallel:` | ✅ | ✅ |
| **Streaming** | ❌ | ❌ | ❌ | ✅ `--stream` |
| **Background** | ❌ | ❌ | ❌ | ✅ `--background` |
| **Replay** | ❌ | ❌ | ❌ | ✅ `export`/`replay` |

### Extensibility

| | Job Workflows | Hybrid | Agent Workflows | Recipes |
| - | :-: | :-: | :-: | :-: |
| **Custom actions** | ✅ YAML, file, built-in | ✅ (via job engine) | ❌ | ❌ |
| **Custom tools** | ✅ (agent steps) | ✅ | ✅ Tool plugins | ✅ `tools.py` |
| **Conditionals** | ✅ `if:` expressions | ✅ `if:` | ❌ (LLM decides) | ❌ (LLM decides) |
| **CLI flags** | ✅ Custom `flags:` | ✅ | ❌ | ❌ |
| **Env vars** | ✅ `${{ env.X }}` | ✅ | ❌ | ✅ via config |
| **Variables** | ✅ `vars:` + `--var` | ✅ | ✅ `--var` | ✅ `--var`, `--input` |

***

## Decision Guide

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
flowchart TD
    A["What do you need?"] --> B{"Needs AI / LLM?"}
    B -->|No| C{"Interactive?"}
    C -->|Yes| SC["Slash Command"]
    C -->|No| JW["Job Workflow"]
    B -->|Yes| D{"Extend or Execute?"}
    D -->|Execute| E{"Multi-agent?"}
    E -->|"Single agent + shell"| JWA["Job Workflow (agent steps)"]
    E -->|"Multi-agent + shell"| HW["Hybrid Workflow"]
    E -->|"Agents only"| F{"Share externally?"}
    F -->|No| AW["Agent Workflow"]
    F -->|Yes| R["Recipe"]
    D -->|Extend| G{"What kind?"}
    G -->|"New action"| T["Tool"]
    G -->|"Expertise / knowledge"| S["Skill"]
    G -->|"System behavior"| H["Hook"]
    G -->|"Bundle everything"| P["Plugin"]

    style JW fill:#10B981,color:#fff
    style JWA fill:#10B981,color:#fff
    style HW fill:#8B5CF6,color:#fff
    style SC fill:#6B7280,color:#fff
    style AW fill:#6366F1,color:#fff
    style R fill:#F59E0B,color:#fff
    style T fill:#10B981,color:#fff
    style S fill:#06B6D4,color:#fff
    style H fill:#EF4444,color:#fff
    style P fill:#8B5CF6,color:#fff
```

| If you want to... | Use |
| - | - |
| Automate shell commands / CI/CD | **Job Workflow** |
| Create reusable build actions | **Job Workflow** + [Custom Actions](/docs/features/custom-actions) |
| Mix shell + single AI agent in a pipeline | **Job Workflow** (agent steps) |
| Add a quality gate to a pipeline | **Job Workflow** (`judge:` step) |
| Mix shell + multi-agent collaboration | **Hybrid Workflow** |
| Run checks in parallel | **Hybrid Workflow** (`parallel:` step) |
| Orchestrate AI agents on a task | **Agent Workflow** |
| Share an AI workflow as a package | **Recipe** |
| Improve AI output iteratively | **Recipe** (`judge`/`optimize`) |
| Serve an AI workflow as an API | **Recipe** (`serve`) |
| Generate a job workflow from a prompt | `praisonai workflow auto --type job` |
| Give an agent a new capability | **Tool** |
| Give an agent expertise / personality | **Skill** |
| Add logging / security / guardrails | **Hook** |
| Bundle tools + skills + hooks for distribution | **Plugin** |
| Quick interactive commands | **Slash Command** |

***

## Best Practices

<AccordionGroup>
  <Accordion title="Start with Agent Workflows">
    For a single AI task, use an `Agent` in Python or a YAML agent workflow — no job steps required.
  </Accordion>

  <Accordion title="Use Job Workflows for CI/CD">
    When you need shell commands, conditionals, or quality gates, choose a job workflow with `run:`, `agent:`, or `judge:` steps.
  </Accordion>

  <Accordion title="Package with Recipes for distribution">
    Share workflows externally with `praisonai recipe pack` — includes lifecycle tools like `judge` and `optimize`.
  </Accordion>

  <Accordion title="Extend agents, not workflows">
    Add capabilities via **Tools** and **Skills** on the agent; use **Plugins** when bundling tools, hooks, and recipes for install.
  </Accordion>
</AccordionGroup>

***

## Agent Execution Configuration

Control per-agent execution limits with `ExecutionConfig`:

<Card title="ExecutionConfig SDK Reference" icon="code" href="/docs/sdk/reference/praisonaiagents/modules/feature_configs">
  Full parameter reference for ExecutionConfig
</Card>

**Precedence ladder:**

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Level 1: String preset
agent = Agent(execution="thorough")   # "fast" | "balanced" | "thorough" | "unlimited"

# Level 2: ExecutionConfig (full control)
agent = Agent(execution=ExecutionConfig(
    max_iter=50,
    max_rpm=100,
    context_compaction=True,
    max_budget=1.00,
))

# Preferred modern form — max_steps is the unified budget honoured by both loops
agent = Agent(execution=ExecutionConfig(max_steps=50))
```

`max_steps` is the unified outer-loop step budget honoured identically by both tool-execution loops. Detect truncation with `agent.last_stop_reason == "max_steps"`. See [Step Budget](/docs/features/max-steps).

| Option | Type | Default | Description |
| - | - | - | - |
| `max_steps` | `int \| None` | `None` | Unified tool-use budget honoured by both loops. `None` falls back to `max_iter`. Must be `>= 1`. |
| `max_iter` | `int` | `20` | Legacy per-loop iteration cap, used when `max_steps` is unset |
| `max_rpm` | `int \| None` | `None` | Max requests per minute. When set to a positive int with no explicit `rate_limiter`, the Agent auto-builds `RateLimiter(requests_per_minute=max_rpm)`. Explicit `rate_limiter` takes precedence. `max_rpm <= 0` raises `ValueError` at construction (validated before precedence, so `max_rpm=0` still raises even with a `rate_limiter`). See [Rate Limiter](/docs/features/rate-limiter). |
| `max_execution_time` | `int \| None` | `None` | Max wall-clock seconds per run |
| `max_retry_limit` | `int` | `2` | Max LLM retries on error |
| `max_tool_calls_per_turn` | `int` | `10` | Max tool calls per single turn |
| `code_execution` | `bool` | `False` | Appends an `execute_code` tool to the agent |
| `code_mode` | `str` | `"safe"` | `"safe"` (subprocess, timeout enforced) or `"unsafe"` (in-process, tool-capable, no hard timeout). Unknown values raise `ValueError` |
| `code_tools` | `bool` | `False` | Allow code to call agent tools directly (needs `code_mode="unsafe"`). Model-generated code calls the agent's tools through the same policy / guardrail / approval gate as the normal tool-call loop (agent-wide `guardrails=`, per-tool `@tool(input_guardrails=/output_guardrails=)`, `PolicyEngine`, `PermissionManager` deny-rules, `require_approval`). |
| `code_tools_allow` | `list \| None` | `None` | Per-run allow-list of tool names callable from code; the tool must also be in `Agent(tools=[...])` |
| `context_compaction` | `bool` | `False` | Auto-compact context when approaching token limit |
| `max_context_tokens` | `int \| None` | `None` (auto-detect from model window) | Token limit before compaction triggers. Unset → auto-derived from the active model's context window; explicit int always wins. See [Context Compaction → Auto-sized trigger](/docs/features/context-compaction#auto-sized-trigger-the-new-default). |
| `max_budget` | `float \| None` | `None` | Hard USD budget limit per run |
| `on_budget_exceeded` | `str` | `"stop"` | `"stop"` / `"warn"` / callable |
| `parallel_tool_calls` | `bool` | `False` | Execute batched tool calls in parallel. **Single source of truth** for this setting; `ToolConfig.parallel` is a deprecated alias for it. |

<Note>
  **Behavioural changes in PraisonAI PR #4975:** `code_execution=True` now grants a real `execute_code` tool, `code_mode` is a real switch (safe = subprocess w/ enforced timeout; unsafe = in-process, no hard timeout), unknown `code_mode` raises `ValueError`, and `code_tools=True` without `code_mode="unsafe"` warns. See [Execution → Code-execution options](/docs/features/execution) and [Code Execution with Tools](/docs/features/code-execution-with-tools).
</Note>

<Warning>
  `context_compaction` defaults to `False` but will default to `True` in the next release. Explicitly set `context_compaction=False` to preserve current behavior.
</Warning>

<Note>
  `code_sandbox_mode` still exists (default `"sandbox"`) and round-trips through `to_dict()` / `from_dict()`, but it is **inert** — no execution path reads it. To isolate code the model runs, use `AgentFlow(run_on=…)` (shared sandbox) or `Agent(sandbox=…)` (explicit `execute_code()`). See [Placement](/docs/features/placement).
</Note>

<Note>
  **Behavioural change:** `code_execution`, `code_mode`, `code_tools`, and `code_tools_allow` are now wired to real behaviour — `code_execution=True` grants an `execute_code` tool, an unknown `code_mode` raises `ValueError`, and `timeout` is enforced only in `"safe"` mode. See [Execution](/docs/features/execution) and [Code Execution with Tools](/docs/features/code-execution-with-tools).
</Note>

***

## Source Files

| System | Core Implementation | CLI |
| - | - | - |
| Job Workflows | `cli/features/job_workflow.py` | `cli/commands/workflow.py` |
| Hybrid Workflows | `cli/features/hybrid_workflow.py` | `cli/commands/workflow.py` |
| Agent Workflows | `cli/features/workflow.py` | `cli/commands/workflow.py` |
| Workflow Generation | `auto.py` (`JobWorkflowAutoGenerator`) | `workflow auto --type job` |
| Recipes | `recipe/core.py` + `cli/features/recipe.py` | `cli/commands/recipe.py` |
| Tools | `praisonaiagents/tools/` | Via agent config |
| Skills | `praisonaiagents/skills/` | `praisonai skill` |
| Plugins | `praisonaiagents/plugins/` | `praisonai plugin` |
| Hooks | `praisonaiagents/hooks/` | Programmatic |
| Slash Commands | In-memory registry | `/cmd` in REPL |

***

## Related

<CardGroup cols={2}>
  <Card title="Job Workflows" icon="list-check" href="/docs/features/job-workflows">
    Deterministic + agent-centric steps
  </Card>

  <Card title="Hybrid Workflows" icon="shuffle" href="/docs/features/hybrid-workflows">
    Job + multi-agent in one pipeline
  </Card>

  <Card title="Rate Limiter" icon="gauge" href="/docs/features/rate-limiter">
    Auto-wire `max_rpm`, precedence, and burst/TPM control
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.