promptise 1.1.0

Promptise Foundry - Production-ready agentic framework for building advanced AI agent systems and multi-agent orchestration

Promptise Foundry

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

---

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.

 

Get started in 30 seconds

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())

_{One call. The agent finds its tools on the MCP server on its own. Memory, guardrails, cache, and tracing are each a single line —
and the ones you don't pass cost you nothing. Works with OpenAI, Anthropic, Gemini, or a local model via Ollama.}

 

The five parts of the framework

_{Each replaces a stack of libraries you'd otherwise wire together yourself.}

01 🤖	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. Agent docs →
02 🧠	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. Reasoning docs →
03 🔧	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. MCP docs →
04 ⚡	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. Runtime docs →
05 ✨	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. Prompts docs →

 

Built for putting agents in front of customers

_{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 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 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. 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
🔧  MCP Server & Client Build a tool once; every agent can use it. Explore →	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. 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
✨  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

_{Also in the docs}

📚  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

 

Ecosystem

_{Promptise plugs into what your team already runs — and runs fully offline when it has to.}

  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}

 

_{Want to ship with us? See CONTRIBUTING.md · join Discussions · file an issue.}

---

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.}}