The first full-stack Agentic Engineering framework.
Build agents and the tools they use. Design how they reason. Run them as autonomous, governed systems.
Ship them to real customers — multi-tenant, secure, and observable. One framework, not a dozen libraries.
Website · Documentation · Quick Start · Blog · Discussions
Promptise is one framework for the whole job of building with AI agents — the agents, the tools they use, the reasoning behind them, the runtime that keeps them running, and the security and governance to put them in front of customers. Not a single feature, but the full stack you'd otherwise assemble from a dozen separate libraries.
Most agent stacks are assembled by hand: a model SDK, a tool layer, a vector database, auth, guardrails, a job runner, logging — glued together and kept alive by you. Promptise pulls all of it into one framework. build_agent() and a Python decorator give you the agent and its tools; memory, security, multi-tenancy, human approvals, a runtime, and observability are already inside, each switched on with a parameter.
The impact: you build what your agent does, not the ten libraries underneath it. A prototype becomes something you can put in front of paying customers without rebuilding the production layer each time — and the same install that runs one agent on your laptop runs a fleet serving real users.
pip install promptiseimport asyncio
from promptise import build_agent, PromptiseSecurityScanner, SemanticCache
from promptise.config import HTTPServerSpec
from promptise.memory import ChromaProvider
async def main():
agent = await build_agent(
model="openai:gpt-5-mini",
servers={
"tools": HTTPServerSpec(url="http://localhost:8000/mcp"),
},
instructions="You are a helpful assistant.",
memory=ChromaProvider(persist_directory="./memory"), # remembers across calls
guardrails=PromptiseSecurityScanner.default(), # blocks injection, redacts PII
cache=SemanticCache(), # serves similar queries instantly
observe=True, # traces every step
)
result = await agent.ainvoke({
"messages": [{"role": "user", "content": "What's the status of our pipeline?"}]
})
print(result["messages"][-1].content)
await agent.shutdown()
asyncio.run(main())and the ones you don't pass cost you nothing. Works with OpenAI, Anthropic, Gemini, or a local model via Ollama.
Each replaces a stack of libraries you'd otherwise wire together yourself.
|
🤖 |
One function turns any model into a working agent.
|
|
🧠 |
Decide how the agent thinks — or use a preset. Most tasks run fine on the default tool loop. When you need more control, lay out the agent's reasoning as a graph you can read and change: think, use tools, check its own answer, then respond. Seven presets cover common shapes — research, debate, plan-act-reflect, one-shot self-verify, write-one-program — and you build your own when none fit. No black box. |
|
🔧 |
Build a tool once; every agent can use it. Write a Python function, add |
|
⚡ |
Keep agents running, on budget, and recoverable. Turn an agent into a long-running process that wakes on a schedule, a webhook, or a file change. It writes down every step, so a crash resumes from where it stopped instead of starting over. Set limits on tool calls and spend, watch for stuck or looping behavior, and require a human when it hits something risky. Run one, or a fleet across machines. |
|
✨ |
Prompts you can version and test, not strings you paste. Assemble a system prompt from typed blocks with a token budget, let it change across the phases of a conversation, and check it with the same kind of tools you use for code. Version prompts, roll back a bad one, and trace exactly how each was built — so a prompt change is a reviewable diff, not a mystery. |
The parts most teams end up hand-building. Here they're in the framework, off by default, on with a parameter.
-
Multi-tenant, by construction. Tag a request with a tenant, and every place data lives — memory, cache, conversations, rate limits, audit — stays separated per customer. Two customers who both have a user named
alicecan 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 customer's data with a single call 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-prem or regulated customers who can't send data out. → Guardrails · Model Setup
Every capability, grouped by pillar and linked to its docs. Six parts, one framework.
| 📚 Guides & Labs |
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 |
| 📖 API reference |
Agent · Config · Memory · RAG · Sandbox · Observability · Identity · MCP server · MCP client · Prompts · Runtime · Cross-agent · SuperAgent · Utilities |
| 🚀 Start here |
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 |
+ any LangChain BaseChatModel · FallbackChain for automatic failover · Model setup →
Local embeddings · air-gapped model paths · per-tenant isolation · Memory →
Session ownership enforced · per-tenant isolation for cache and guardrails · Conversations →
A verifiable identity per agent — no shared keys · Agent Identity →
8 transporters: OTel · Prometheus · Slack · PagerDuty · Webhook · HTML · JSON · Console · Observability →
Docker + seccomp + gVisor + capability dropping · Kubernetes health probes · Sandbox →
stdio · streamable HTTP · SSE · HMAC-chained audit logs
Contributing · Security · License: Apache 2.0
Built by Promptise
Formerly DeepMCPAgent — a public preview of one sliver of this framework (MCP-native agent tooling). Promptise Foundry is the full system it hinted at: reasoning engine, agent runtime, prompt engineering, sandboxed execution, governance, and observability.