Plano

Plano is an AI-native proxy and data plane for agentic apps — with built-in orchestration, safety, observability, and smart LLM routing. by @salman_paracha

[Plano @planoai_dev]

Plano is an AI-native data plane for AI agents - a framework-friendly, protocol-native fabric that lets you focus on what really matters: your agents' product logic.

[Goli.eth @golieth_io]

Your patience is an asset.

Get paid for it.

Goli.eth

[xNode @xNodePro]

managing AI agents should be as easy as installing apps on your phone

we moved OpenClaw deployment from a Linux terminal to a simple dashboard.

start in 2 clicks. 99.9% uptime in the cloud.
no DevOps skills needed.

this is what future infrastructure looks like 👇
https://t.co/TQoN3dfnNC

[Grove Finance @grovedotfinance]

Grove Data Note 11
Week of April 27, 2026

[METATRONICS @metatronics_]

Most people don’t lose money in crypto because the market is impossible.
They lose because they trade without structure.
No risk management.
No trading plan.
No understanding of liquidity.
No clear exit strategy.
No emotional discipline.
Metatronics Crypto Academy is built to change that.
CTA:
Learn before you trade.

[Plano @planoai_dev]

https://t.co/9QpozC5DBs

[Salman Paracha @salman_paracha]

Also you'll find first implementation ideas of Signals in https://t.co/ExfeiBqnwm

[Salman Paracha @salman_paracha]

Just released support for preference-based LLM routing for OpenClaw in Plano 🚀

Those who use @openclaw know that it can churn through tons of tokens. So you have two options pay for those token or plugin in a cheaper alternative and sacrifice perf. What if you don’t have to make this trade off? What if you could route traffic for certain tasks to @claudeai and others to!@Kimi_Moonshot ?

With Plano you can: https://t.co/BioebnQLJx. Check out our demos folder under LLM routing for more details

[Akshay 🚀 @akshay_pachaar]

There's a pattern that keeps repeating in software.

First, everyone focuses on the building problem. Frameworks emerge, mature, and become genuinely good.

Then suddenly, the constraint flips.

We saw this with neural networks. PyTorch and TensorFlow were excellent for building models.

But deploying them meant dealing with different formats, runtimes, and infrastructure headaches. ONNX emerged to bridge that gap.

We're watching the same pattern unfold with Agents right now.

Frameworks like LangGraph, CrewAI, and LlamaIndex are mature enough that building an agent is no longer the hardest part.

The hard part comes after: delivering agents to production

→ Which agent should handle this request?
→ How to apply guardrails consistently?
→ How to swap models without refactoring?
→ How to close the loop between observability and continuous learning?
→ How to cap resource usage across Agents?

These aren't Agent problems but rather delivery problems.

And such delivery concerns can't live inside the framework. Not because frameworks are bad, but because when they own delivery, you're locked into one framework's abstractions and quirks as the system evolves.

That's fine for a prototype, but fragile in production.

Here's a mental model you can use to simplify this:

Inner loop is an Agent's business logic. This includes prompts, tools, and reasoning.

Outer loop is everything else. This includes the plumbing work, like routing, orchestration, guardrails, and observability.

Most frameworks blur this boundary, wiring outer loop concerns into application code, making it challenging to go from demo to production.

One approach I find interesting is moving the outer loop into a separate infra layer entirely.

Plano is an open-source project (5k+ stars) that implements this idea.

It acts as a data plane between your app and your agents/LLMs, handling routing, orchestration, and guardrails at the infra level.

When you use Plano, the Agent (regardless of the framework) becomes a simple HTTP server, and Plano handles which one gets invoked, in what order, with what policies.

The interesting part is how it does routing:

Instead of brittle if/else chains or embedding classifiers, Plano uses small, purpose-built LLMs that route based on natural language preferences.

You describe what each agent is good at. The router figures out where to send each request.

Here's what the config looks like in practice:

```
llm_providers:
- model: openai/gpt-4o
- - routing_preferences:
- - - name: complex_reasoning
- - - description: deep analysis & reasoning

- model: deepseek/deepseek-coder
- - routing_preferences:
- - - name: code_generation
- - - description: generating code and scripts
```

Once you do this, adding a new model means adding a few lines to the config. Changing the routing policy just requires updating the description.

Guardrails follow the same pattern through Filter Chains. You define them once and apply them everywhere.

And the application code stays untouched throughout.

This is what separating the inner loop from the outer loop looks like in practice. Your agent handles business logic. Infrastructure handles the rest.

Plano is fully open source under Apache 2.0. You can see the full implementation on GitHub and try it yourself.

I've shared the GitHub repo in the replies.

[Paddy Srinivasan @paddix]

Big step forward for @digitalocean 's Agentic Inference Cloud.

We’ve acquired Katanemo Labs - makers of PlanoAI (
https://t.co/t4PmIMBcZ3) bringing powerful capabilities to help developers build and run AI agents in production.

The future isn’t just inference.
It’s thinking (intelligence) + doing (agents).

Katanemo’s Plano technology adds:
• Faster, safer deployment of agentic workflows
• Real-time optimization in production
• Deep observability into agent behavior
• More stuff we will be announcing shortly!!

This is how we collapse the AI stack — from model → agent → production — into one platform.

Welcome @salman_paracha and team !🚀

Read more: https://t.co/4vKq0Tc5VM

[Plano @planoai_dev]

No lock-in. No black boxes. Just an open, intelligent fabric for building more reliable agentic AI applications.

Built by engineers with roots in the Envoy ecosystem, Plano brings production-grade reliability to agent traffic and prompt hestration—while staying fully extensible.

[Plano @planoai_dev]

https://t.co/xrDZeqZq6d

[Plano @planoai_dev]

Plano is an AI-native data plane for AI agents - a framework-friendly, protocol-native fabric that lets you focus on what really matters: your agents' product logic.

[Plano @planoai_dev]

Plano takes over the plumbing work that slows teams down when handling and processing prompts, including detecting and blocking jailbreaks,

[Plano @planoai_dev]

routing tasks to the right model or agent for better accuracy, applying context engineering hooks, and centralizing observability across agentic interactions