Agent as the runtime

Agentify Cloud

Agentify Cloud treats the agent as the runtime for tomorrow's software. Instead of hand-writing every handler, schema, and workflow, the human defines intent, policy, and yes-or-no boundaries. FastAPI and FastMCP keep the transport familiar while Pi AgentSession turns ordinary HTTP and MCP requests into service behavior.

Quick start See the request loop View runtime surfaces PyPI package
intent treat routes and payloads as service intent policy define yes, no, and boundaries in AGENTS.md runtime let Pi AgentSession produce service behavior validate JSON and HTML response contracts before returning retry failed envelopes with compact failure context operate one thin server as agent-native infrastructure
Agentify Cloud generated story page from a route request

Install and run

One package, one local agent runtime.

Install the PyPI package, write a small AGENTS.md gate, then start the server. Every route becomes intent for the agent runtime, while clients still call plain HTTP or MCP.

1. Install from PyPI 
uv pip install agentify-cloud
2. Define the agent gate 
# AGENTS.md
# Agent Gate

- /dashboard/* returns complete HTML for GET.
- POST and MCP calls return structured JSON.
- Never expose secrets or local environment variables.

The server reads AGENTS.md once at startup and injects it into every delegated prompt.

3. Start the runtime 
agentify server --port 8000

Use --md-file ./runtime/AGENTS.md for a different rule file, or -api_key abc123 to require caller authentication.

4. Call any route 
curl http://127.0.0.1:8000/dashboard/today

curl -X POST http://127.0.0.1:8000/tasks/create \
  -H 'content-type: application/json' \
  -d '{"instruction":"create a task summary","title":"Ship README"}'

GET returns HTML. POST returns JSON. MCP clients connect at /mcp and call the generic agentify tool.

The software primitive shifts

Most cloud services bind routes to fixed handlers, schemas, and workflows. In an agent-native stack, the primitive moves up: the human writes intent and policy, while the agent becomes the runtime that decides how behavior should be produced inside the contract.

Intent replaces handlers

Routes, payloads, and tool calls describe desired behavior instead of mapping directly to hand-written functions.

Policy replaces scattered control flow

AGENTS.md defines what is allowed, denied, constrained, and required before the agent acts.

The agent becomes infrastructure

Pi AgentSession becomes the adaptive execution layer behind ordinary HTTP and MCP surfaces.

Runtime surfaces

Agentify Cloud is not a chatbot attached to an API. It is a gateway where agents become infrastructure: the transport stays stable, the contract stays bounded, and service behavior is generated from governed intent.

GET as intent

A route can become an HTML page when the agent runtime returns a JSON object with a content field.

POST as instruction

A request body becomes an intent envelope, and the runtime returns strict JSON to the caller.

MCP as governed action

FastMCP exposes agent-backed tools while preserving a typed client-facing protocol and policy gate.

Request loop

The gateway owns transport, contracts, retries, and lifecycle. The agent is the runtime that turns intent into adaptive service behavior inside those boundaries.

1. Receive intent

FastAPI handles HTTP requests and FastMCP handles tool calls without asking the client to learn a new protocol.

2. Apply policy

The gateway combines endpoint, payload, API key context, output format, and AGENTS.md yes-or-no boundaries.

3. Run the agent

The agent runtime returns JSON or HTML-in-JSON, and the gateway validates the envelope before responding.

ingress

HTTP or MCP request enters one thin server.

policy

AGENTS.md defines allowed behavior and style.

delegate

Pi AgentSession receives the governed intent envelope.

validate

Gateway checks response shape and retries once if needed.

return

Client receives ordinary HTML or JSON.

Generated service examples

These examples show the same runtime pattern: a normal route is interpreted as intent, the agent runtime produces behavior, and the gateway returns a conventional browser result.

Route intent becomes a page

A browser GET request can ask for a story page. The gateway does not hard-code that page; it asks the agent runtime to produce an HTML payload that satisfies the response contract.

GET HTML in JSON route intent
Styled story page generated by Agentify Cloud

Visual runtime output

A route can request a chart or report. In production, the policy gate decides whether the agent may use demo data, retrieved data, or restricted tools.

report policy gate visual result
Market trend graph generated by Agentify Cloud

Plain output can evolve

A first response can be simple. The same endpoint can later be guided toward richer layout, stricter structure, or domain-specific service behavior without changing the transport surface.

iteration same route service behavior
Simple story page generated by Agentify Cloud

What Agentify Cloud owns

Agentify Cloud owns the gateway contract: FastAPI routes, FastMCP tools, request envelopes, AGENTS.md policy injection, Pi AgentSession delegation, response validation, retry context, and process lifecycle. The agent is the runtime. It adapts service behavior while the gateway keeps cloud-facing contracts predictable.