Foundry

Website  ·  Docs  ·  Quick start  ·  How it works  ·  Examples  ·  Discussions

What Promptise is

The framework for agentic intelligence.

Promptise gives you everything an agentic system needs, in one place and working together from the first line: agents that think, safe ways for them to act in your systems, and a harness that keeps them running and accountable. You decide what your agent should do; Promptise takes care of everything around it.

Start with one agent on your laptop and grow it into a fleet running real work, with the same framework and the same way of building all the way through. No rewrite in between, and nothing to stitch together yourself.

Layer	What it does for you
Agent · it thinks	Agents that work through a task step by step, check their own work and get it right.
Interface · it acts	Safe access to your tools, your data and the systems you already run.
Harness · it operates	Keeps your agents running around the clock, within budget, and accountable for everything they do.

Get started in 30 seconds

pip install promptise
export OPENAI_API_KEY=sk-...

import asyncio
from promptise import build_agent, tool


@tool
def order_status(order_id: str) -> dict:
    """Look up the status of an order."""
    return {"order_id": order_id, "status": "shipped", "eta": "Friday"}


async def main():
    agent = await build_agent(
        model="openai:gpt-5-mini",
        instructions="You are a helpful support assistant.",
        extra_tools=[order_status],
        observe=True,  # traces every step, token and cost
    )
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "Where is order A-1001?"}]}
    )
    print(result["messages"][-1].content)
    await agent.shutdown()


asyncio.run(main())

Any Python function with @tool becomes a tool; its type hints are the schema. To give the agent the tools of an MCP server, add it to servers; the agent discovers its tools by itself:

from promptise.config import HTTPServerSpec

agent = await build_agent(
    model="openai:gpt-5-mini",
    servers={"tools": HTTPServerSpec(url="http://localhost:8000/mcp")},
)

To start a full project instead, run promptise init --project my-bot.

Any model, one string. openai:gpt-5-mini · anthropic:claude-sonnet-4-5 · azure:chat-prod · gemini:gemini-2.5-pro · bedrock:… · ollama:llama3.1. The same string works in build_agent(), .superagent files and every CLI command, and promptise models check <string> tells you exactly what a provider still needs. → Model setup

Run your project

promptise.toml is to an agent project what package.json is to a Node project: it names the main file, the scripts and the environment the project needs. promptise run runs your program like python main.py; with dev tools, the terminal UI or the HTTP API it also instruments every agent the program builds, with no code changes.

promptise init --project my-bot   # promptise.toml, agent.py, main.py, .env.example
promptise run                     # run main.py with the project's environment
promptise run --devtools          # live traces, tool calls, tokens and cost
promptise run --tui               # the full terminal UI
promptise run --serve             # an HTTP API for your agent
promptise run --prod              # JSON logs, preflight checks, graceful SIGTERM

[scripts] work like npm scripts (promptise run dev), and --watch restarts on every save. → Projects & promptise run

One request, through the whole system

A customer writes in at three in the morning. The runtime wakes the agent, its identity is established, the input is checked, it gathers context, plans, calls a tool through MCP, a person approves the refund, it checks its own work, answers, and every step lands in the audit trail.

Already have an API? MCPcast it.

promptise mcpcast openapi.yaml --profile standard --auth env-token

MCPcast reads an OpenAPI or Swagger document and writes a real, reviewed MCP server: a small set of tools an agent can actually use, chosen and described for agents. Reads by default; writes only when you ask, and every one of them approval-gated on the server, so a person signs off before anything changes, whichever MCP client calls it.

What comes out is a project, not a script: an installable package, a launcher, a generated test suite, pyproject.toml, a Dockerfile and a README, all regenerated from mcpcast.plan.yaml, the one file you edit. --eval grades the result A to F with a real agent before you ship, and plain promptise mcpcast opens a guided setup in the terminal. Above: the real output for the Swagger Petstore spec. → MCPcast, end to end

Built for governance and structure

For people and teams who need their agentic systems to be accountable: who did what, on whose behalf, within which limits. These are part of the framework, not something you add later.

• Multi-tenant, by construction. Tag a request with a tenant, and every place data lives — memory, cache, conversations, rate limits, audit — stays separated per tenant. Two tenants who both have a user named alice can never see each other's data. It's a structural rule, not a filter you have to remember on every query. → Multi-Tenant Platform guide

• Human approval, enforced on the server. Mark a tool as needing sign-off and the approval is required no matter which app calls it — including one you didn't write. Denies on timeout, rejects self-approval, records who approved what. → Approval Gates

• A real identity for each agent. Agents authenticate as themselves to the APIs they call, backed by Microsoft Entra ID, AWS, Google Cloud, SPIFFE, or plain OIDC — so you can retire the shared API key, and every action traces to the person it acted for, even across agents calling agents. → Agent Identity

• Audit you can hand to a reviewer. Every action is written to a tamper-evident chain, tied to the tenant and the user. Delete one user's cached answers, memories and recorded events with purge_user() when they ask. → Auth & Security

• Runs offline. The security models, embeddings, and vector store can all run locally — so the whole stack works air-gapped, for on-premises and regulated environments where data can't leave. → Guardrails · Model Setup

Everything Promptise ships

The Promptise Agent

One function turns any model into a production agent.

Explore →

Setup   Build · Server config · Network server · SuperAgent files · Custom patterns · Cross-agent

Memory & state   Memory · RAG · Conversations · Semantic cache · Context engine

Security   Guardrails · Approval · Auto-approval · Sandbox

Performance   Tool optimization · Fallback · Adaptive strategy

Execution   Streaming · Events · Observability

Reference   Config · Types · Default prompt · Callbacks · Tools · Env resolver · Exceptions · CLI

Reasoning Engine

Reasoning as a graph you can read and change.

Explore →

Graph   Overview · Nodes · Edges · Flags · Internals

Patterns & skills   Prebuilt patterns · Skills · Skill registry · Custom reasoning

Runtime   Tool injection · Processors · Hooks · Serialization

Prompt Engineering

Prompts built like software, versioned and tested.

Explore →

Build   PromptBlocks · ConversationFlow · Builder · Loader & templates · Shell injection

Strategies   Strategies · Chaining · Context & variables

Quality   Guards · Inspector · Testing · Suite & registry

MCP Server, Client & MCPcast

Build a tool once; every agent can use it.

Explore →

Server   Guide · MCPcast an existing API · Fundamentals · Routers & middleware · Auth & security · Multi-tenancy · Approval gates · Production · Caching · Observability · Resilience · Queue · Advanced · Deployment · Testing

Client   Guide · Tool adapter

Agent Runtime

Run agents unattended, on budget, recoverable.

Explore →

Core   Processes · Orchestration API · Manager · Context & state · Lifecycle · Hooks · Conversation

Governance   Mission · Budget · Health · Secrets

Triggers   Overview · Cron · Event & webhook · File watch

Journal & recovery   Overview · Backends · Replay · Rewind

Config & scale   Options · Manifests · Meta-tools · Coordinator · Discovery · Dashboard · CLI

Agent Identity

An authenticated identity for every agent.

Explore →

Core   Overview · Quickstart · Guide · Architecture · Security · Migration

Providers   Microsoft Entra ID · AWS IAM · Google Cloud · SPIFFE / SPIRE · Generic OIDC

Building agents · Context lifecycle · Code-action · Production MCP servers · Agentic runtime · Prompt engineering · Multi-user systems · Agent-to-MCP identity · Secure multi-tenant platform · Multi-agent coordination  •  Labs: Customer support · Data analysis · Code review · Pipeline observer

Agent · Config · Memory · RAG · Sandbox · Observability · Identity · MCP server · MCP client · Prompts · Runtime · Cross-agent · SuperAgent · Utilities

Installation · Extras · Quick start · Cookbook · Why Promptise · What is MCP? · Model setup · Best LLMs · Key concepts · Glossary  •  More: Blog · Showcase · Examples · Migration · Changelog · FAQ · Contributing

Works with what you already run

Area	Works with
Models	OpenAI · Anthropic · Azure OpenAI & AI Foundry · Gemini & Vertex AI · Bedrock · Mistral · Groq · Ollama · Hugging Face · any LangChain chat model · FallbackChain for failover → Model setup
Memory & vectors	ChromaDB · Mem0 · Sentence Transformers · local embeddings for air-gapped installs → Memory
Conversations	PostgreSQL · Redis · SQLite · in-memory, with session ownership enforced → Conversations

---

Contributing  ·  Security  ·  Changelog  ·  License: Apache 2.0

Built by Promptise · questions and ideas in Discussions · bugs in Issues

Formerly DeepMCPAgent, a public preview of one part of this framework (MCP-native agent tooling).