How Echo works
What Echo is, how it's built, and what it's doing right now.
What Echo is. Echo is a developer assistant for Resonate — retrieval-augmented answers grounded in the docs, the SDKs, and a corpus of real examples. You can reach it five ways: the web app, the API, the CLI, Discord, and MCP.
How Echo is built. Echo runs as two tiers. The query path is synchronous: a request embeds the question, runs a hybrid vector and full-text search over the corpus, reranks the hits, and asks Claude to write the answer — all on a single request, start to finish in a few seconds, most of that the model writing. The corpus those queries read is maintained separately, by a set of durable workflows on Resonate: nightly crawls of the docs, SDKs, and examples; a weekly pull from Discord; a daily examples-validation pass; and the briefing that produces this page. Both tiers share one Postgres database that holds the corpus as vector embeddings and a full-text index.
Running the background work on a durable execution engine has a useful side effect: the Resonate server records the state and timing of every step as it goes. The pipeline numbers below are read straight from those records — and because each step is durable, a crashed run replays and finishes instead of failing.
Pipeline health
Each durable pipeline is a Resonate workflow, and the call graph under each tile is the live shape of its last run — the same picture resonate tree prints for a running workflow. The curated source beside each graph is the workflow that drew it: every ctx.run step is one node. Green nodes succeeded, red failed, amber is still in flight. Because the run is durable, a partial run retries on its own instead of counting against the success rate.
Durable workflows
- Success 7d
- 100%
- p50 duration
- 59.0s
- Last run
- within the last 6h
// echo-ingest · nightly
function* runIngest(ctx: Context) {
const runId = new Date(yield* ctx.date.now())
.toISOString().slice(0, 10);
// crawl every source, then chunk + embed + index
const staged = yield* ctx.run(crawlCorpus, runId);
return yield* ctx.run(processStaged, staged, runId);
}
function* crawlCorpus(ctx: Context, runId: string) {
// one durable child per source —
// docs · SDKs · examples · Discord, and ~20 more
const docs = yield* ctx.beginRun(crawlAndStageDocs, runId);
const sdks = yield* ctx.beginRun(crawlAndStageTsSdk, runId);
const skills = yield* ctx.beginRun(crawlAndStageSkills, runId);
const discord = yield* ctx.beginRun(crawlAndStageDiscordThreads, runId);
return [...(yield* docs), ...(yield* sdks),
...(yield* skills), ...(yield* discord)];
}- Success 7d
- 100%
- p50 duration
- 900ms
- Last run
- within the last 6h
// echo-examples-health · ingests the daily examples-ci report
function* runExamplesHealthBrief(ctx: Context, report: ExamplesCiReport) {
yield* ctx.run(persistRunStep, report);
// diff today against the last two days
const yesterday = yield* ctx.run(fetchYesterdayStep, report.run_date);
const twoDaysAgo = yield* ctx.run(fetchTwoDaysAgoStep, report.run_date);
const diff = computeDiff(report, yesterday, twoDaysAgo);
yield* ctx.run(postParentStep, report, diff);
// two-strike failures get a GitHub issue
yield* ctx.run(fileNewIssuesStep, diff.new_failing, report.run_date);
}- Success 7d
- 100%
- p50 duration
- 1.9s
- Last run
- within the last 6h
// echo-proactive · posts the daily community brief
function* runBrief(ctx: Context) {
const now = yield* ctx.date.now();
const briefDate = new Date(now).toISOString().slice(0, 10);
const since = new Date(now - 24 * 3600_000).toISOString();
const window = yield* ctx.run(briefFetchWindow, briefDate, since);
const enriched = yield* ctx.run(briefUpdateProfiles, window);
const candidates = yield* ctx.run(briefGenerateCandidates, enriched);
const scored = yield* ctx.run(briefQualityGate, briefDate, candidates);
yield* ctx.run(briefPost, briefDate, scored);
return { posted: scored.length };
}Synchronous query path
The three query surfaces aren't durable — they answer on the request thread and share one path.
- Answered 7d
- 100%
- p50 latency
- 3.8s
- Queries 7d
- 2
- Answered 7d
- 100%
- p50 latency
- 5.1s
- Queries 7d
- 7
- Answered 7d
- —
- p50 latency
- —
- Queries 7d
- 0
Daily query volume
By surface, last 90 days.
What people ask about
A lightweight classifier sorts each question into one of sixteen topics. This page shows only those bucket counts over the last 30 days — never the question text. Arrows compare the last 7 days to the 7 before.
Feedback
Last 30 days.
Latency
p50 / p95, last 30 days.