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

The five parts of the framework

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

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

_{Also in the docs}

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}

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