Promptise Foundry

The foundation layer for agentic intelligence.

Ship full-stack agentic systems the way they're meant to be built —
production-ready, secure by default, with the developer experience modern Python deserves.

Website  ·  Documentation  ·  Quick Start  ·  Showcase  ·  Discussions

---

One Python framework. The full agentic stack.

_{From your first agent to a fleet running in production — without gluing libraries together.}

• Agents that discover tools and remember context.
• MCP servers with access control, governance, and audit trails — multi-user, scalable, secure by default.
• Reasoning engine you can shape, like bricks.
• Autonomous runtime that recovers from crashes and stays within budget.

 

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"),
        guardrails=PromptiseSecurityScanner.default(),
        cache=SemanticCache(),
        observe=True,
    )

    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. Auto tool discovery from MCP servers. Memory auto-searched before every invocation.
Guardrails block injection and redact PII. Semantic cache serves similar queries instantly. Full observability.}

 

Five pillars. One framework.

_{Each pillar replaces an entire category of libraries you would otherwise assemble yourself.}

01 🤖	Agent Turn any LLM into a production-ready agent with one function call. build_agent() · auto MCP tool discovery · semantic tool optimization (40–70% fewer tokens) · 3 memory providers with auto-injection · 4 conversation stores · 6-head security scanner · semantic cache with per-user isolation · sandboxed code execution · auto-approval classifier · pluggable RAG · streaming · model fallback · adaptive strategy. Agent docs →
02 🧠	Reasoning Engine Compose reasoning the way you compose code. Not a black box. PromptGraph with 20 node types — 10 standard (PromptNode, ToolNode, RouterNode, GuardNode, ParallelNode, LoopNode, HumanNode, TransformNode, SubgraphNode, AutonomousNode) and 10 reasoning (ThinkNode, PlanNode, ReflectNode, CritiqueNode, SynthesizeNode, ValidateNode, ObserveNode, JustifyNode, RetryNode, FanOutNode). 7 prebuilt patterns (react, peoatr, research, autonomous, deliberate, debate, pipeline). 18 node flags for typed capabilities. Agent-assembled paths from a node pool. Lifecycle hooks. Skill registry. JSON serialization. Reasoning docs →
03 🔧	MCP Server SDK Production server and native client for the Model Context Protocol — multi-user, scalable, secure by default. @server.tool() with auto-schema from type hints · JWT + OAuth2 + API-key access control · role/scope guards · 12+ middleware (rate limit, circuit breaker, audit, cache, OTel) · HMAC-chained audit logs · priority job queue with retries and progress · versioning + transforms · OpenAPI import · MCPMultiClient federation · live 6-tab dashboard · TestClient for in-process testing · 3 transports (stdio, HTTP, SSE). MCP docs →
04 ⚡	Agent Runtime The operating system for autonomous agents. 5 trigger types (cron, webhook, file watch, event, message) · crash recovery via journal replay · 5 rewind modes · 14 lifecycle hooks · budget enforcement with tool costs · health monitoring (stuck, loop, empty, error rate) · mission tracking with LLM-as-judge · secret scoping with TTL and zero-fill revocation · 14 meta-tools for self-modifying agents · 37-endpoint REST API with typed client · live agent inbox · distributed multi-node coordination. Runtime docs →
05 ✨	Prompt Engineering Prompts built like software. Not strings. 8 block types with priority-based token budgeting · conversation flows that evolve per phase · 5 composable strategies (chain_of_thought + self_critique) · 4 perspectives · 14 context providers auto-injected every turn · SSTI-safe template engine with opt-in shell · 5 guards · SemVer registry with rollback · inspector that traces every assembly decision · test helpers (mock_llm(), assert_schema()) · chain, parallel, branch, retry, fallback. Prompts docs →

 

Documentation

Quick Start → Your first agent in 5 minutes. pip install, point at an MCP server, ship.		Key Concepts → Architecture, design principles, the five pillars.
Building Agents → Step-by-step, simple to production.	Reasoning Engine → Graphs, nodes, flags, patterns.	MCP Servers → Production tool servers with access control, middleware, and audit trails.
Agent Runtime → Autonomous agents with governance, triggers, and crash recovery.	Prompt Engineering → Composable blocks, strategies, flows, and guards. Prompts built like software, not strings.
Showcase → End-to-end working patterns and reference implementations.		API Reference → Every class, method, parameter.

 

Ecosystem

_{Promptise plugs into what your team already runs.}

  Models  

_{+ any LangChain BaseChatModel · FallbackChain for automatic failover}

  Memory & Vectors  

_{Local embeddings · air-gapped model paths · prompt-injection mitigation built in}

  Conversation Storage  

_{Session ownership enforced · per-user isolation for cache and guardrails}

  Observability  

_{8 transporters: OTel · Prometheus · Slack · PagerDuty · Webhook · HTML · JSON · Console}

  Sandbox & Infrastructure  

_{Docker + seccomp + gVisor + capability dropping · Kubernetes-native health probes}

  Protocols  

_{stdio · streamable HTTP · SSE · HMAC-chained audit logs}

 

Star history

_{Promptise Foundry is open-source and growing fast. If it saves you time, drop a ⭐ — it genuinely helps.}

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

---

Contributing  ·  Security  ·  License: Apache 2.0

_{Built by Promptise}

_{^{Formerly known as DeepMCPAgent — a public preview of one sliver of this framework (MCP-native agent tooling). Promptise Foundry is the full system it was a teaser for: reasoning engine, agent runtime, prompt engineering, sandboxed execution, governance, and observability.}}