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.

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

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