PraisonAI

PraisonAI — **Hire a 24/7 AI Workforce.** Stop writing boilerplate and start shipping autonomous, self-improving agents that research, plan, and execute tasks across your apps. From one agent to an entire organization, deployed in 5 lines of code. ```bash curl -fsSL https://praison.ai/install.sh | bash ```

``` ██████╗ ██████╗ █████╗ ██╗███████╗ ██████╗ ███╗ ██╗ █████╗ ██╗ ██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██╔═══██╗████╗ ██║ ██╔══██╗██║ ██████╔╝██████╔╝███████║██║███████╗██║ ██║██╔██╗ ██║ ███████║██║ ██╔═══╝ ██╔══██╗██╔══██║██║╚════██║██║ ██║██║╚██╗██║ ██╔══██║██║ ██║ ██║ ██║██║ ██║██║███████║╚██████╔╝██║ ╚████║ ██║ ██║██║ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝╚═╝ pip install praisonai ``` --- ## Use Cases AI agents solving real-world problems across industries: | Use Case | Description | |----------|-------------| | **Research & Analysis** | Conduct deep research, gather information, and generate insights from multiple sources automatically | | **Code Generation** | Write, debug, and refactor code with AI agents that understand your codebase and requirements | | ✍️ **Content Creation** | Generate blog posts, documentation, marketing copy, and technical writing with multi-agent teams | | **Data Pipelines** | Extract, transform, and analyze data from APIs, databases, and web sources automatically | | **Customer Support** | Deploy 24/7 support bots on Telegram, Discord, Slack with memory and knowledge-backed responses | | ⚙️ **Workflow Automation** | Automate multi-step business processes with agents that hand off tasks, verify results, and self-correct | --- ## Meet your first Agent (Under 1 Minute) 1. Install the lightweight core SDK: ```bash pip install praisonaiagents export OPENAI_API_KEY="your-api-key" ``` 2. Run your first autonomous agent: ```python from praisonaiagents import Agent # Give your agent a goal, and watch it work. agent = Agent(instructions="You are a senior data analyst.") agent.start("Analyze the top 3 tech trends of 2026 and format as a markdown table.") ``` --- ## The Five-Layer Agent Stack Most frameworks hand you one or two layers and leave the rest as homework. PraisonAI covers **all five** — plus the outer layer that decides *where* your agent actually runs. Each layer wraps the one inside it. When an agent misbehaves, the layer tells you where to look. ``` … ``` | Layer | The question it answers | PraisonAI | |:--|:--|:--| | **1 · Prompt** | Did I say it clearly? | `instructions=`, `role`/`goal`/`backstory`, `output=`, `templates=` | | **2 · Context** | Is the right thing in the window? | `memory=`, `knowledge=`, `context=`, handoff `ContextPolicy` | | **3 · Harness** | Can it act, and be checked? | `tools=`, `MCP()`, `guardrails=`, `approval=`, `hooks=`, `sandbox=` | | **4 · Loop** | When do we stop? | `execution=ExecutionConfig(...)`, `reflection=`, `autonomy=`, doom-loop detection | | **5 · Graph** | Who runs when, and who checks whom? | `AgentFlow`, `route()`, `parallel()`, `loop()`, `repeat()` | | **⬡ Managed** | *Where does it actually run?* | `tools_run_on="docker"` — one shared sandbox for the tools, or `run_on="anthropic"` for the whole agent | ### Layer 1 · Prompt — *Did I say it clearly?* Role, instructions, examples, output format. ```python from praisonaiagents import Agent agent = Agent( role="Senior Data Analyst", goal="Turn raw numbers into decisions", output="verbose", # markdown-formatted output ) agent.start("Summarise Q3 revenue trends") ``` ### Layer 2 · Context — *Is the right thing in the window?* Write, select, compress, isolate — the four context operations, one parameter each. ```python from praisonaiagents import Agent agent = Agent( instructions="You are a support engineer.", memory={"user_id": "u-42"}, # write — persists across runs (needs a user_id) knowledge=["docs/"], # select — retrieves only what's relevant context="summarize", # compress — auto-compacts before the limit ) ``` > **Isolate** is `handoffs=[specialist]` — a sub-agent inherits the last few messages and the intersection of your tools, not your whole transcript. [ Handoffs](https://docs.praison.ai/docs/concepts/handoffs) ### Layer 3 · Harness — *Can it act, and be checked?* *Agent = Model + Harness.* Tool dispatch, plus the guides that steer before acting and the sensors that observe after. ```python from praisonaiagents import Agent, MCP, tool @tool def deploy(env: str) -> str: """Deploy the current build to an environment.""" return f"Deployed to {env}" agent = Agent( name="ReleaseEngineer", instructions="You are a release engineer.", tools=[deploy, MCP("npx -y @modelcontextprotocol/server-filesystem /tmp")], approval=True, # guide — human gate before risky tools run ) agent.start("Deploy to staging, then list the files you can read") ``` ### Layer 4 · Loop — *When do we stop?* Hard iteration caps, budget ceilings, no-progress detection and completion checks — every brake is explicit. ``` … ``` > **Doom-loop detection is on by default.** Repeated identical tool calls and A→B→A→B oscillation get caught — while a poller whose output keeps changing does not. [ Doom Loop Detection](https://docs.praison.ai/docs/features/doom-loop-detection) ### Layer 5 · Graph — *Who runs when, and who checks whom?* Topology as a versionable artifact: prompt chaining, routing, parallelisation, orchestrator-worker. ```python from praisonaiagents import AgentFlow from praisonaiagents.workflows import route, parallel, repeat flow = AgentFlow(steps=[ classifier, route({"bug": [bug_agent], "feature": [feature_agent], "default": [triage]}), parallel([reviewer, tester]), # fan out, join automatically repeat(editor, until=lambda ctx: "approved" in ctx.previous_result.lower(), max_iterations=3), # evaluator–optimizer ]) flow.run("Ticket #123: login fails on Safari") ``` > The same graph is expressible in YAML with no Python at all. [ AgentFlow](https://docs.praison.ai/docs/concepts/agentflow) ### ⬡ Outside the stack: Managed Agents — *Where does it actually run?* The harness is commoditising; **where** the agent executes is the next multiplier. Rather than burning your laptop's CPU, hand an agent a short-lived cloud sandbox — repo, tools and tests run there. ```bash pip install praisonai ``` The simplest way in is `tools_run_on=` — one whole team or workflow shares **one** sandbox, so a file written by step 1 is there for step 2. Thinking stays on your machine: ```python from praisonaiagents import Agent, AgentFlow writer = Agent(name="Writer", instructions="You write files.") reader = Agent(name="Reader", instructions="You read files.") flow = AgentFlow(tools_run_on="docker", steps=[writer, reader]) # or e2b | modal | daytona | flyio flow.run("Write 'hello' to /workspace/note.txt, then read it back") ``` Same thing with no Python at all: ```yaml name: remote-demo tools_run_on: docker # every step shares one sandbox agents: writer: {role: Writer, goal: Write files} reader: {role: Reader, goal: Read files} steps: - agent: writer action: "Write 'hello' to /workspace/note.txt" - agent: reader action: "Read /workspace/note.txt" ``` For a single agent, two words cover it — and they answer different questions: ``` … ``` Ask any object where it runs, and it will tell you: ```python >>> Agent(name="builder", instructions="x", tools_run_on="docker") Agent(name='builder', thinks_on='this machine', tools_run_on='a Docker container') >>> agent.where_does_it_run() Thinking (the AI model calls) happens on this machine. Tools run on a Docker container. Your own tools (check_db) still run on this machine -- only shell, file and code tools move. They read and write this machine's files. ``` Naming a place that cannot do the job is a typo, not a preference, so it says so: ```python >>> Agent(name="x", instructions="i", run_on="e2b") TypeError: Agent(run_on='e2b') is not valid: run_on= places the whole agent -- model calls, loop and tools -- on a managed runtime, and 'e2b' runs commands but cannot host an agent loop. To run only the tools there: Agent(tools_run_on='e2b') ``` To run one block of code somewhere else, name the place on that call: ```python agent.execute_code_sync("print(6 * 7)", run_in="sandlock") # kernel-enforced ``` See what is running and reclaim strays: ```bash praisonai managed ps # list running sandboxes praisonai managed stop --all # reclaim them ``` Sandboxes shut themselves down when idle (`auto_shutdown`, `idle_timeout_s`), and a post-setup snapshot is reused so the next run skips the image pull and dependency install. Commit a `.praisonai/environment.yaml` and the environment travels with the repo. > [20 runnable examples](examples/python/managed-agents/) · manage sessions with `praisonai managed sessions list ` or `praisonai managed sessions resume ""` Stack framing adapted from [The Five-Layer Agent Stack](https://mer.vin/2026/07/five-layer-agent-stack-match-bug-to-right-layer/) and [Agent Harnesses vs Orbs](https://mer.vin/2026/08/agent-harnesses-vs-orbs-why-remote-sandboxes-beat-local-agent-loops/). --- ## The PraisonAI Ecosystem Start simple with the core SDK, or expand to full visual builders and dashboards when you're ready. * **Core SDK (`praisonaiagents`)**: For pure Python development. `pip install praisonaiagents` * **PraisonAI CLI (`praisonai`)**: For terminal-based developers. `pip install praisonai` * **Claw Dashboard**: Connect agents directly to Telegram, Slack, or Discord. `pip install "praisonai[claw]"` * **Flow Visual Builder**: Drag-and-drop workflow creation. `pip install "praisonai[flow]"` * **PraisonAI UI**: Clean chat interface. `pip install "praisonai[ui]"` ### JavaScript SDK ```bash npm install praisonai ``` ## Supported Providers & Features Powered by 100+ LLMs (OpenAI, Anthropic, Gemini & local models).

View all 24 providers with examples | Provider | Example | |----------|:-------:| | OpenAI | [Example](examples/python/providers/openai/openai_gpt4_example.py) | | Anthropic | [Example](examples/python/providers/anthropic/anthropic_claude_example.py) | | Google Gemini | [Example](examples/python/providers/google/google_gemini_example.py) | | Ollama | [Example](examples/python/providers/ollama/ollama-agents.py) | | Groq | [Example](examples/python/providers/groq/kimi_with_groq_example.py) | | DeepSeek | [Example](examples/python/providers/deepseek/deepseek_example.py) | | xAI Grok | [Example](examples/python/providers/xai/xai_grok_example.py) | | Mistral | [Example](examples/python/providers/mistral/mistral_example.py) | | Cohere | [Example](examples/python/providers/cohere/cohere_example.py) | | Perplexity | [Example](examples/python/providers/perplexity/perplexity_example.py) | | Fireworks | [Example](examples/python/providers/fireworks/fireworks_example.py) | | Together AI | [Example](examples/python/providers/together/together_ai_example.py) | | OpenRouter | [Example](examples/python/providers/openrouter/openrouter_example.py) | | HuggingFace | [Example](examples/py