What it does:

- Pre-built agents: Database queries, API calls, web search, data analysis, code generation.

- YAML-based workflows: Define your agent architecture without rebuilding orchestrators.

- Built-in guardrails: SQL injection protection, SSRF blocking, table/domain whitelisting.

- Visual traces: See what happened, where it failed, and how much it cost.

Why I built it:

Every time I build a multi-agent system, I spend 2-3 weeks creating the same infrastructure: orchestrators that route tasks, database agents with SQL guardrails, retry logic, loop limiting, and cost tracking. Then another week of debugging when things break. I wanted to ship features, not plumbing.

Most frameworks are bulky and complex. You just want pre-built components you can compose like AWS services.

What Echos gives you:

- Ship faster: Pre-built agents you compose in YAML.

- Debug in minutes: Visual traces show exactly what happened, where it failed, and how much it cost.

- Prevent disasters: Built-in guardrails (SQL injection protection, SSRF blocking, loop limiting) catch 80% of dangerous operations.

- Control costs: Per-agent spending limits prevent runaway bills.

Try it: Clone https://github.com/treadiehq/echos or go to https://echoshq.com

import { EchosRuntime } from '@echoshq/runtime';

const runtime = new EchosRuntime({ apiKey: process.env.ECHOS_API_KEY, apiUrl: process.env.ECHOS_API_URL, workflow: './workflow.yaml' // Define agents and routes in YAML });

// Simple usage await runtime.run({ task: 'Analyze customer churn', memory: { year: 2024, region: 'north' } });

Tech:

- NestJS for the backend API: Needed structured DI and middleware for auth.

- Postgres for trace storage: JSON columns for flexible span logs, native SQL performance.

- Resend for magic link authentication: Reliable email delivery without managing SMTP.

- Nuxt 3 for the dashboard: SSR for fast initial load, client-side interactivity for live traces.

- Railway for deployment: Fast deploys. First time trying it. My previous default is Digital Ocean.

What I learned:

- Time saved is the real value: Teams don't want another framework, they want to ship faster.

- Debugging is 50% of the work: Visual traces that show the full execution path are essential.

- Simple guardrails work: Blocking DELETE/DROP and unknown domains catches most disasters.

- YAML > Code for config: Non-engineers can edit workflows without touching code.

Looking for feedback:

- Does this solve a real problem for you?

- Which agents would you use most? database, API calls, web search, data analysis, or code generation?

- Is YAML configuration expressive enough, or do you need more programmatic control?

- What agents should we add next? (GitHub, Slack, email, cloud APIs?)

- Would you use this for autonomous agents, or just one-off tasks?

- Would this save you time on your next multi-agent project?

- What's missing that would make this immediately useful?

Thank you!