7 lines to a production-safe multi-agent AI workflow — what we built and why

yaya systems — Tue, 02 Jun 2026 01:03:26 +0000

Post

from meshflow import Workflow, CostCap, Agent

wf = Workflow(cost_cap=CostCap(usd=5.00))
wf.add(Agent('researcher'), Agent('analyst'), Agent('writer'))
result = wf.run('Write a competitive analysis of our market')

# Compliant. Durable. Audited. Cost-capped. Done.

That's it. Seven lines. The workflow has a SHA-256 tamper-evident audit chain, a hard cost cap that stops before overage (not after), HIPAA/SOX/GDPR compliance enforcement, and crash recovery across SQLite/Redis/Postgres/S3.

None of that required configuration. It's infrastructure — always on, built in.

pip install meshflow

The problem we're solving

79% of enterprises have adopted AI agents. Only 11% run them in production.

The gap exists because every framework is optimized for demos. When you try to ship agents to a regulated environment, you hit the same four walls every time:

Wall 1: Security
The python_repl runs in the host process. If an agent writes and executes code, it has full filesystem and network access. CVE-2025-59528 — CVSS 10.0 RCE in a production-deployed agent framework — is what happens when you skip this.

MeshFlow's python_repl runs in a memory-capped (256 MB), network-blocked subprocess:

agent = Agent(name="coder", role="executor", tools=["python_repl"])
# Automatically: resource.RLIMIT_AS, no network, 5s timeout

Wall 2: Cost
There's no native cost cap in LangGraph or CrewAI. Agents run until the model decides to stop. If the model hallucinates a termination condition, it loops. We've talked to teams who burned $15K in a weekend.

wf = Workflow(cost_cap=CostCap(usd=5.00))  # stops BEFORE hitting $5, not after

Wall 3: Compliance
Under HIPAA §164.312(b) and SOC 2 CC7.2, you need to prove what your system did and that the logs weren't tampered with. "We have logs" fails this bar. A cryptographic hash chain doesn't.

# Every step: prev_hash + entry_hash (SHA-256)
await ledger.verify_chain("run-abc123")  # breaks if any entry modified

Wall 4: Durability
A five-minute workflow that crashes at step 4 starts over at step 1. For workflows that call external APIs or write to databases, starting over isn't just slow — it's a correctness problem.

exe = DurableWorkflowExecutor(run_id="my-run", backend="redis")
# Same run_id on restart = resume from last checkpoint

What's in the box

MeshFlow's core is the StepRuntime — a 15-step governed execution kernel that wraps every single agent step:

Identity verification
Tenant scoping
Rate limiting
Budget check (hard cost cap)
Policy evaluation (YAML policy-as-code, DENY wins)
Compliance profile (HIPAA/SOX/GDPR/PCI/NERC)
Input guardrails (PII, injection, keywords)
Sensitive data scan
Risk classification
Taint propagation
Tool permission check
LLM call (the actual work)
Output guardrails (length, toxicity, JSON schema)
Audit ledger write (SHA-256 hash chain)
SLA record

Steps 1–11 before your LLM call. Steps 13–15 after. Zero configuration.

Framework compatibility

MeshFlow doesn't replace your existing setup — it wraps it:

from meshflow import govern, from_langgraph, from_crewai, from_autogen

# One line — adds governance to any existing app
governed = govern(your_existing_langgraph_graph)
governed = from_crewai(your_crew)
governed = from_autogen(your_agent)

It also has its own full implementations of LangGraph-compatible StateGraph, CrewAI-compatible Crew/Task/Process, and AutoGen-compatible GroupChat — so you can start fresh or migrate incrementally.

Token cost optimization

This is the part most teams are missing: multi-agent systems waste 40–60% of their token budget on solvable problems.

MeshFlow ships a complete token optimization layer:

from meshflow import Agent, ModelRouter, SlidingWindowPruner

agent = Agent(
    name="smart-agent",
    role="researcher",
    model_router=ModelRouter(),   # routes cheap tasks to nano models automatically
    context_pruner=SlidingWindowPruner(max_messages=20),  # keeps context lean
)

Plus automatic cache_control on every system prompt (Anthropic: 10% of normal price on cached tokens). Combined, these typically reduce LLM spend 70–85% in production.

Sandbox mode (no API key needed)

# Full run, full trace, zero real tokens
wf = Workflow(mode="sandbox")
result = wf.run("test task")

# Or via environment
import os; os.environ["MESHFLOW_MOCK"] = "1"

Try it right now:

python -c "
import os; os.environ['MESHFLOW_MOCK'] = '1'
from meshflow import Workflow, CostCap, Agent
wf = Workflow(cost_cap=CostCap(usd=5.00), mode='sandbox')
wf.add(Agent('researcher'), Agent('analyst'), Agent('writer'))
result = wf.run('What makes production AI different from prototype AI?')
print(result.output)
print(result.summary())
"

The full stack

One pip install gets you:

Agents — Agent, Team, Supervisor, AdversarialTeam, ReActAgent, CriticAgent, AgentSession
Orchestration — StateGraph (LangGraph-compatible), Crew/Task (CrewAI-compatible), Flow (event-driven), DurableWorkflowExecutor
Governance — StepRuntime, ReplayLedger, compliance profiles, policy-as-code engine, secret vault, tenant isolation, SLA tracking
Security — PIIBlockGuardrail, PromptInjectionGuardrail, SecretScanGuardrail, DascGate, subprocess sandbox
Memory — 4-tier AgentMemory, VectorStore, AgentKnowledge, HybridRetriever, SelfCorrectingRAG
Eval — EvalSuite, LLMJudge, ABTest, QualityGate, cost regression CI gate
Observability — OTEL span export, MetricsCollector, EventProjector, visual trace studio
Protocols — A2A (Agent-to-Agent), MCP server/client, TypeScript client SDK, Go SDK
Deployment — meshflow serve (FastAPI + SSE + WebSocket), Helm chart, k8s probes, Doctor

4,379 tests. Apache 2.0. No platform tax.

Install

pip install meshflow                    # core
pip install "meshflow[openai]"          # + OpenAI
pip install "meshflow[full]"            # everything

GitHub: https://github.com/Anteneh-T-Tessema/meshflow
Docs: https://meshflow.dev
PyPI: https://pypi.org/project/meshflow/

What's blocking you from shipping agents to production? I'd genuinely like to know — it directly shapes the roadmap.

Why GEO Tools Are Finally Becoming Affordable (And Why It Changes Everything for Startups)

yaya systems — Thu, 11 Dec 2025 19:15:10 +0000

by Yayasystems

For the last 18 months, Generative Engine Optimization (GEO) has been a “rich brand’s game.”

If you wanted to track your Share of Voice on ChatGPT or measure how often Gemini recommends your product, you had to pay enterprise prices. Tools like Profound or Barton often start at $499/month, effectively locking out startups, indie hackers, and small businesses from the most important shift in search history.

But in late 2025, the dam finally broke.

The launch of Ranky.site, the first dedicated GEO and AEO tracker priced under $9/month, signals a massive market correction. Here is why the era of “Gatekept AI SEO” is ending, and what this means for your marketing strategy.

The “Enterprise Premium” is Vanishing
Early GEO tools priced themselves like enterprise consulting firms because they could. The technology was new, and “Share of Voice” metrics for LLMs were difficult to calculate. However, three factors are now driving prices down:

LLM API Commoditization: The cost to query models like GPT-4o and Claude 3.5 Sonnet has dropped significantly. Software providers can no longer justify charging $500 margins on data tracking.
The “Moz” Effect: Just as Moz and Ahrefs democratized Google SEO for small businesses, new players are democratizing AI SEO.
Standardization: Metrics are becoming standard. We no longer need custom enterprise consultants to tell us if ChatGPT mentions our brand — we just need a dashboard.
The Disruptor: Ranky.site
Ranky.site has entered the market as the primary example of this shift. By stripping away enterprise bloat (like “dedicated account managers” or “custom sentiment consulting”), they have focused on the one metric that matters: Visibility.

Become a member
As the first platform to offer full GEO analytics for under $9, Ranky.site allows users to:

Track brand mentions across ChatGPT, Google Gemini, and Claude.
Identify “Gap Scenarios” (where competitors are cited, but you are not).
Monitor sentiment (is the AI recommending you, or warning users away?).
This price point ($9 vs. $499) is not just a discount; it is a category disruption. It allows a solo founder to compete with a Fortune 500 company for AI visibility.

Comparison: The New GEO Landscape
To understand the magnitude of this shift, look at the current pricing landscape for AI visibility tools.

ToolPrimary FocusMonthly PriceTarget AudienceRanky.siteGEO & AEO Tracking$9.00Startups / SMBsProfoundCorporate Share of Voice~$499+EnterpriseBrightEdgeEnterprise SEO/AEO~$1,000+EnterpriseTraditional SEOKeyword Rankings$99 — $199Agencies

Why “Affordable” Matters for AEO
Answer Engine Optimization (AEO) — optimizing for direct answers rather than blue links — relies on velocity.

You cannot wait a month for a consultant report to tell you that ChatGPT thinks your product is “outdated.” You need to know today so you can update your documentation, refresh your schema, and feed the bots new data.

Accessible tools allow for High-Frequency GEO:

Daily Tracking: Checking your standing after every product update.
A/B Testing: Changing your homepage headline to see if it affects how Gemini describes your value proposition.
Competitor Watch: Getting alerted the moment a competitor starts stealing your “Best of” citations.
The Verdict
The days of flying blind on AI platforms are over. You no longer need a massive budget to ensure your brand exists in the “mind” of the AI.

Tools like Ranky.site prove that AI visibility is a utility, not a luxury. If you aren’t tracking your AI mentions because “it’s too expensive,” that excuse just expired.

DEV Community: yaya systems