00 AGENTOPS · LOCAL-FIRST

Build agentic backends without a staging environment.

Platypus Engine is the 15 MB Go daemon we run on our laptops. It gives us real OpenTelemetry traces for FastAPI, Pydantic, and LangGraph — on localhost, in milliseconds.

Install in 30s → See capabilities

Apache 2.0 Zero config OTLP native

~/projects/agentic-rag — zsh

Compatible with the stack you already ship

FastAPI Pydantic v2 LangGraph LangChain OpenAI Anthropic OpenTelemetry Azure Blob Qdrant pgvector Pinecone Redis DuckDB Grafana

01 The problem

Our feedback loop had slipped from milliseconds to coffee breaks. So we built the fix.

WITHOUT PLATYPUS ~94s per try

0sedit code
5sdocker compose up
38saz login · VPN handshake
60sre-deploy to staging
78stail logs, grep, miss
88sadd print(), restart

WITH PLATYPUS ~1.4s per try

0sedit code
0.2ssave → daemon picks up
0.6strace lands at :7700
1.4sclick the failing span

02 A field note

A platypus is a duck-billed, egg-laying, venomous mammal. It belongs nowhere, and everywhere. That’s the right mascot for the tool we’re building — one that lives between our laptops and our cloud, a creature of the seam.

— our note · platypusengine/README.md, line 1

[ THE OBSERVATION DECK ]

A real lineage graph at localhost:7700.

Every span, every tool call, every prompt mutation — rendered as a graph you can actually navigate. No JSON spelunking.

localhost:7700 / traces / 9f3a8c…

FastAPI POST /ask 412 ms

Pydantic Query.validate 2 ms

LangGraph build_graph 18 ms

Mock · qdrant search() 6 ms

tool · anthropic messages.create 324 ms

return answer 1 ms

SPAN · MESSAGES.CREATE

provideranthropic modelclaude-opus-4-7 input1,847 tok output412 tok latency324 ms parentbuild_graph

TOOL CALLS

{
  "name": "search_docs",
  "args": {
    "query": "refund policy",
    "k": 5
  },
  "latency_ms": 6
}

03 Capabilities

What we’re shipping — six guarantees, no asterisks.

i.
Ephemeral infra-mimicry

Mock Azure Blob, queues, vector stores as goroutines. Reset under 10 ms.

azure-blob · qdrant · pgvector · redis
```
# before
from platypus import trace  ←
@trace("ask")
async def ask(q):  …
```
```
# with platypus
async def ask(q):  …
# that's it.
```
ii.
Native Python interception

No imports. No decorators. Audit hooks at process start trace FastAPI & Pydantic v2.

fastapi · pydantic · starlette
iii.
Agent-aware tracing

LangGraph nodes, tool calls, prompts, tokens — a real span tree, not a JSON blob.

langgraph · openai · anthropic
iv.
Real-time lineage UI

Hover a node, see its prompt. Replay from any span.

next 15 · react-flow · duckdb-wasm
v.
OTLP, end-to-end

Pure OpenTelemetry. Migrate to prod without a rewrite.

otlp/grpc · otlp/http · zipkin
vi.
Under 150 MB resident · Go single binary

Go single binary. Runs alongside Cursor, Docker, your dev server — no fan-spin. No JVM. No Electron.

go 1.23 · macOS · linux · wsl

04 Architecture

Four decoupled layers we designed so your code never knows which environment it’s in.

Same binary on your laptop. Same binary in production. Swap any layer — the others don’t notice.

L1

Application

Your FastAPI controllers, your LangGraph orchestrators, your Pydantic models. Unchanged.

client code
L2

Platypus Interceptor

A Python module that lives inside your runtime. Captures inputs and outputs, serializes to OTLP, ships via gRPC to the daemon. Silent.

middleware
L3

Platypus Daemon

A Go process listening on :4317. Accepts OTLP, intercepts outbound HTTP for known cloud APIs, reroutes to local mocks, writes to DuckDB.

go · single binary
L4

Observation Deck

Next.js UI and a terminal CLI. Reads from the daemon’s DuckDB. Renders the span tree, the memory graph, and the diff between runs.

next.js · cli

05 The integration

We refuse to make you add imports or decorators. Running the daemon is the integration.

main.py unchanged

# Same file you would deploy to Azure App Service.
# Platypus auto-instruments at process start — nothing to add.

from fastapi import FastAPI
from pydantic import BaseModel
from langgraph.graph import StateGraph

app = FastAPI()

class Query(BaseModel):
    question: str

@app.post("/ask")
async def ask(q: Query):
    graph = build_agent_graph()        # traced
    answer = await graph.ainvoke(q)   # traced (nodes, tools, tokens)
    return {"answer": answer}

~ $ bash first run

$ pip install platypus-engine
$ platypus init
✓ daemon up on :4317
✓ ui at http://localhost:7700
✓ mock azure-blob ready
✓ mock qdrant ready

$ uvicorn main:app
# … hit your endpoint, then …
$ platypus tail
[platypus] 1,847 spans · 23 langgraph nodes · p99 412 ms

06 Operating envelope

<10ms Full mock-state reset, measured at the daemon CLI.
<150MB Resident memory ceiling. Hard cap, enforced.
1.8M s⁻¹ Span ingest on a 2024 MacBook Pro (M3 Pro, 18 GB).
100% OpenTelemetry conformance — by construction, not by adapter.

07 Day in the life

A day on your keyboard. Three clients. One morning. Zero staging deploys.

08:14
Pull, init, mock

Tokyo client pings you. Run platypus init; it spins up Azure Blob and Qdrant on your laptop.
08:21
Replay the failed trace

The lineage UI surfaces a cached tool-call on a stale model version. No print() required.
09:02
Run platypus share

A signed read-only execution graph lands in their Slack. They open it. Three weeks of trust bought in nine minutes.
11:30
Switch to Berlin

Different stack. Same daemon. Same muscle memory. Two retainers billed before lunch.

08 Pricing

Engine / core

Apache 2.0 · Free forever

$0 / developer / month

Daemon · SDK · UI · CLI
All cloud mocks
Full OTLP export
Unlimited projects
Community support

Install the daemon

Platypus Cloud

Hosted control plane · Beta Q4 2026

$29 / developer / month, billed annually

Everything in core, plus:
platypus share — signed live graphs
Org accounts, SSO, audit log
Encrypted retention (default 30d)
SLA email support · 1-day response

Join the beta waitlist

We will never paywall the daemon, the SDK, the UI, or the CLI. The only thing money buys is the hosted share-link plane — because that’s the only thing that costs us money to run.

09 FAQ

Does Platypus replace Sentry / Datadog / Honeycomb?

No — local-first dev tooling. Prod traces still flow to your APM over OTLP.

Does my code change?

No imports, no decorators. The daemon registers Python audit hooks at process start.

Why Go for the daemon, not Rust?

Faster builds, simpler distribution. The memory floor is already low enough.

Is any data sent to your servers?

Only when you run platypus share. Otherwise everything stays on-device in DuckDB.

Will the open-source core stay free?

Forever. Apache 2.0. The hosted share-link plane is the only paid surface.

Python & OS support?

Python 3.11+. macOS · Linux · Windows via WSL2. Native Windows on Q1 2027.

How is this different from LocalStack?

LocalStack mocks AWS at the network. Platypus also instruments your runtime — LangGraph, Pydantic, tool calls, tokens.

Can I self-host the share-link plane?

Yes, on the Q1 2027 enterprise tier. Docker image + Helm chart.

10 First run, thirty seconds

Three commands, no account.
Then a real lineage graph at localhost:7700.

$ pip install platypus-engine
$ platypus init
$ open http://localhost:7700

Get in touch → Get on the beta list

Build agentic backends without a staging environment.

Our feedback loop had slipped from milliseconds to coffee breaks. So we built the fix.

A real lineage graph at localhost:7700.

What we’re shipping — six guarantees, no asterisks.

Four decoupled layers we designed so your code never knows which environment it’s in.

Application

Platypus Interceptor

Platypus Daemon

Observation Deck

We refuse to make you add imports or decorators. Running the daemon is the integration.

A day on your keyboard. Three clients. One morning. Zero staging deploys.

Pull, init, mock

Replay the failed trace

Run platypus share

Switch to Berlin

Three commands, no account. Then a real lineage graph at localhost:7700.

Three commands, no account.
Then a real lineage graph at localhost:7700.