What Promptise is
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 promptise
import 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())
Agent
One function turns any model into a working agent.
build_agent() connects to your tool servers, discovers the tools on its own, and gives the agent what it needs to be useful in practice: memory that's searched before every reply, a security scanner that blocks prompt injection and redacts PII, response caching, sandboxed code execution, and full tracing. Each is one parameter. Any model — OpenAI, Anthropic, Gemini, a local model, or anything built on LangChain.
Reasoning Engine
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.
MCP Server SDK
Build a tool once; every agent can use it.
Write a Python function, add @server.tool(), and it becomes an MCP tool with a schema taken straight from your type hints. The same tool works with Promptise agents and with Claude Desktop, Cursor, and any other MCP client. It comes with authentication, per-tool permissions, rate limits, circuit breakers, tamper-evident audit logs, a background job queue, and a test client that runs the whole request path without a network.
Agent Runtime
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.
Prompt Engineering
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.
-
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
Everything Promptise ships
Every capability, grouped by pillar and linked to its docs. Six parts, one framework.
🤖 Agent
One function turns any model into a production agent.
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.
Graph Overview · Nodes · Edges · Flags · Internals
Patterns & skills Prebuilt patterns · Skills · Skill registry · Custom reasoning
Runtime Tool injection · Processors · Hooks · Serialization
🔧 MCP Server & Client
Build a tool once; every agent can use it.
Server Guide · 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.
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.
Core Overview · Quickstart · Guide · Architecture · Security · Migration
Providers Microsoft Entra ID · AWS IAM · Google Cloud · SPIFFE / SPIRE · Generic OIDC
✨ Prompt Engineering
Prompts built like software — versioned and tested.
Build PromptBlocks · ConversationFlow · Builder · Loader & templates · Shell injection
Strategies Strategies · Chaining · Context & variables
Quality Guards · Inspector · Testing · Suite & registry
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
Models
+ any LangChain BaseChatModel · FallbackChain for automatic failover · Model setup →
Memory & Vectors
Local embeddings · air-gapped model paths · per-tenant isolation · Memory →
Conversation Storage
Session ownership enforced · per-tenant isolation for cache and guardrails · Conversations →
Identity & Auth
A verifiable identity per agent — no shared keys · Agent Identity →
Observability
8 transporters: OTel · Prometheus · Slack · PagerDuty · Webhook · HTML · JSON · Console · Observability →
Sandbox & Deployment
Docker + seccomp + gVisor + capability dropping · Kubernetes health probes · Sandbox →
Protocols
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.
No comments yet
Be the first to share your take.