README.md

April 25, 2026 · View on GitHub

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

Promptise Foundry

Get started in 30 seconds

Five pillars. One framework.

01

02

03

04

05

Ecosystem

Star history