Foundry is a Python, Apache-2.0 licensed agentic engineering framework from Promptise that gives developers one install for building AI agents, the tools they call, the reasoning they follow, and the governed runtime that serves them to customers.

What it is

Foundry is a full-stack framework for building AI agents. Its README describes it as one framework rather than a collection of libraries: the agent, the tools the agent uses, the reasoning engine that decides how the agent thinks, the runtime that keeps it running, and the security and governance layer needed to put it in front of paying customers all ship in the same package. The install is published to PyPI as promptise, and the framework lives in the Python ecosystem alongside the model SDKs and agent libraries it absorbs.

The concrete problem it solves is assembly cost. A typical agent stack is built by hand from a model SDK, a tool layer, a vector database, authentication, guardrails, a job runner, and logging, all glued together and kept alive by the team that wrote it. Foundry replaces that hand-assembled stack with a single framework where memory, security, multi-tenancy, human approvals, runtime, and observability are already present and each switched on with a parameter. The stated payoff is that a prototype can become something shippable without rebuilding the production layer, and that the same install which runs one agent on a laptop can run a fleet serving real users.

Key capabilities

• build_agent() turns any supported model into a working agent and discovers tools on its own from connected MCP servers, configured through HTTPServerSpec(url="http://localhost:8000/mcp").
• Persistent memory via ChromaProvider(persist_directory="./memory"), searched before every reply.
• PromptiseSecurityScanner.default() blocks prompt injection and redacts PII, enabled as a single guardrails parameter.
• SemanticCache() serves similar queries from cache instead of re-invoking the model.
• A reasoning engine that lays out agent thinking as a readable graph, with seven presets covering research, debate, plan-act-reflect, one-shot self-verify, and write-one-program shapes.
• An MCP Server SDK where @server.tool() turns a plain Python function into an MCP tool whose schema is derived from type hints, with authentication, per-tool permissions, rate limits, circuit breakers, and tamper-evident audit logs.
• Provider-agnostic model support across OpenAI, Anthropic, Gemini, a local model via Ollama, and anything built on LangChain, plus observe=True tracing of every step.

Who uses it and how

• Teams moving an agent prototype toward paying customers who would otherwise rebuild the production layer, because multi-tenancy, approvals, and observability are already inside.
• Multi-tenant product builders who need governed, secure, observable agent fleets rather than a single laptop agent.
• Tool authors who write one Python function with @server.tool() and reuse it across Foundry agents as well as Claude Desktop, Cursor, and other MCP clients.
• Teams with mixed or local model requirements, since the same code path serves hosted providers and a local model through Ollama.
• Developers who want to control agent reasoning explicitly through graph presets rather than accepting an opaque tool loop, for example research or debate shapes.

Getting started

Install with pip install promptise, then call build_agent() with a model string such as openai:gpt-5-mini and pass the optional parameters for memory, guardrails, cache, and tracing. Documentation, a quick start, and a blog are linked from the project homepage at promptise.com.

How it compares

No list of paid products this project replaces is provided in the facts. Among the tools the facts name, LangChain is positioned as something Foundry builds on rather than competes with, since models built on LangChain work inside Foundry, while MCP clients such as Claude Desktop and Cursor are the other half of the tool story: a tool written once for Foundry's MCP Server SDK works in those clients too. The contrast the README draws is therefore against a hand-assembled stack of separate libraries, not against a single named competitor.

When to use it — and when not to

A self-hoster still operates the pieces the framework does not host: the vector store behind ChromaProvider, the MCP tool servers the agent connects to over HTTP, and credentials for whichever model provider is chosen, whether that is a hosted API or a local Ollama instance. Anyone whose needs are a thin wrapper around one model call should not adopt something that bundles a runtime, security layer, and governance model they will not use. The honest caveat is maturity: with 872 stars and 129 forks, Foundry is early in its adoption curve despite claiming coverage of the full production stack, so teams should weigh that against the framework's breadth before standardising on it.

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