2026-07-16

The Week I Mostly Shut Up

Probably my favorite Stellar Developers meeting so far, and — unusually for me — I spent most of it not talking. The occasion: introducing Stellar Raven, the unified Stellar-ecosystem MCP gateway. My pitch in one line: the first, last, and only thing you need to build on Stellar — Stellar docs and ecosystem context in one connection. You might think "oh, it's just an MCP." You would be mistaken, and I brought four guests to explain why.

Quick introductions. Bri has been on the ecosystem team at the foundation for about four and a half years and does a lot of the storytelling around what Tyler builds — a job description that now includes Raven. Boxy built Stellar Light and focuses on data indexing: making ecosystem data smart and high-quality enough that Raven keeps getting smarter from it. Ralph wears many hats in the ecosystem but joined as the builder of Lumen Loop (lumenloop.com), a discovery platform for everything happening on Stellar. And Tyler — still a developer advocate director, and together with Bri quietly spinning off a new team inside the foundation to work on exactly this kind of thing. Don't tell anybody.

What Raven Actually Is

Tyler's framing: the problem Raven solves is context. It's an MCP (Model Context Protocol) server that aims to ensure agents know the truth about Stellar when you ask a question or build something.

The corpus of Stellar truth is scattered, and some of that is structural. We're open source with a very open culture, so a lot of what's true about Stellar lives outside the foundation's control. We run a hackathon on one SDK version, ship a new release two months later, and now SEO is actively working against us: LLMs index a pile of once-true, now-outdated information. Everyone builds off a Blend or Soroswap repo at a hackathon; those repos are static (you can't update deployed contracts), so freshly generated content keeps encoding stale best practices. Recency is a bad signal when the new content was generated off the old standards; scoring what's actually true is genuinely tricky.

Tyler had solved this for himself with a personal deep-research workflow, but "install these ten skills and four MCP servers" is not a shippable product. Raven is that build workflow surfaced as a single service — the fifth version he's tried to build over almost a year, and it only got serious once Lumen Loop and Stellar Light/Scout existed as APIs he could route to. Under the hood, Raven pulls together Lumen Loop, Stellar Light, the Stellar docs, all the Stellar skills, and the Algolia indexes behind the docs and the site, plus general research tools like Parallel and Perplexity in the research pipeline.

The broader thesis: anyone seriously evaluating chains is comparing Stellar against several ecosystems, each with its own sprawl of bespoke skills and MCPs. Nobody maintains all that. If we want people to give Stellar a fair chance with their LLMs, there has to be one tool. That's the niche.

The Sources: Lumen Loop and Stellar Light

Ralph and Boxy overlap on purpose — two independent sources of ecosystem truth mean you can cross-check what works.

Lumen Loop is content-first and agentically driven: backend agents discover content, attach metadata, generate summaries and embeddings, look up SCF information, occasionally disagree with it and self-correct, and publish the result to an open ecosystem database on GitHub that others (like Boxy) build on. Ralph's favorite party trick lives at labs.lumenloop.com: a constellation view of the entire ecosystem — every piece of content and how it relates to everything else. We've never been able to see that before, and it's just one source behind Raven.

Stellar Light started as a discoverability problem and grew once agents entered the picture. Boxy's current frontier is repo indexing: ingesting thousands of repositories from Electric Capital and other sources and actually trying to understand the code depth inside each one, so questions get answered from real code rather than vibes. It's hard, and token-hungry — Boxy has been hitting model limits doing it.

The shared hope: less time on the boring things. SCF reviews, hackathon judging, hunting for the right link — all of that is exactly the shape of work Raven quickens.

Truth Is a Garden

The part I found most interesting is how Raven improves itself, because the core issue with LLMs is that they don't know when they're wrong. Give an agent disparate sources and superseded information and it will grab something, hold it confidently, and careen off a cliff in a burning cloud of tokens. MCPs don't fix that. Skills don't fix that. Continuous re-research of truth fixes that — Tyler's metaphor: truth is a garden, not granite. Things go live, die, migrate; somebody has to keep re-indexing and re-scoring. Concretely:

• Golden QA. The team mined Stack Exchange, Discord, and old Stella logs for almost 500 common Stellar questions, then ran long, expensive research against each — Lumen Loop, Stellar Light, the docs, the site, web research — to produce golden answers.
• Evals. Ask Raven the same questions, have a model grade Raven's answer against the golden one, and — the fun part — assign blame. Is a miss a Lumen Loop problem? A Stellar Light problem? Are the docs missing something, or contradicted by a repo?
• The loop. Misses land in an improvements directory and become issues on the right repository, where Ralph's and Boxy's agents pick them up. Telemetry (the whole thing runs on Cloudflare) captures what tools got called and what came back, so agent flows can compare what Raven found against what it should have. Bri pointed out this already works in the other direction too: several issues open on the docs repo right now exist because Raven couldn't answer something correctly from the docs — Raven is making the docs better, not just consuming them.

Two real examples of misses: asked about asset issuers in Latin America, Raven almost never surfaced Etherfuse — apparently they don't describe themselves as an asset issuer anywhere, even though everyone expects to find them under that word. And "where can I swap assets on Stellar" almost never returned Sushi, new on Stellar and competing with a crowd of existing swap services. Both became golden questions; both improved. When you hit something like this, open an issue on the Stellar Raven repo — that's the mechanism.

Tyler's longer-term vision is forward-deployed agents: Raven plus opt-in memory and profiles, so an agent embedded with a partner learns you're always asking about, say, Argentine anchors, and gets more specific over time. You could stand up an agent today, hand it the Raven MCP and your Sentry logs, put it on a loop, and have it PR fee optimizations against your own repo. The pieces exist; they just need packaging.

Q&A: Live Data, Cheap Models, and Where to Run It

A viewer asked how much you can learn about real-life anchor operations — which turned into the best design discussion of the call: should Raven serve live data? Tyler's answer is no, mostly. Raven is a model context protocol, not a data API. It shouldn't call the RPC for you; it should tell your agent where the RPC docs are, who provides endpoints, and let your model write the code. Same for the recent explosion of data sources: Mercury (just came back, and very cool), stellarindexer.com, Alchemy's new Stellar API, Dune, the data-lake tooling like Galexie. Your agent doesn't know what it doesn't know — but once Raven points it at the right sources, your agent is the best tool for the job. Tyler's analogy, which I intend to steal: "I'm going to borrow your body to use my brain." We're giving the agent the tools, not building it the house.

The same logic answers the hosted demo question. There's a playground on the Raven site, and you should treat it as exactly that: heavily rate-limited, a really cheap reasoning model, capped search/execute turns — Tyler is understandably not exposing hundreds of dollars of frontier-model compute to the open internet. Use it to see which tools get called and get a feel for the answers (we asked it "who is Justin Rice" live, and for a throttled setup it did honestly fine), but the real product is Raven installed in your own IDE or agent, where a frontier model gets far more out of the same context. That's also why there's a sign-in: a standard OAuth MCP login, needed for rate limiting today and the opt-in memory features later.

Other questions from chat, rapid-fire:

• Test suites and security? Raven would be phenomenal at it as the repo indexing matures — find repos that already cover fuzz testing and common error patterns, then plug that into whatever monitors your backend. The follow-on idea everyone liked: index audit reports. Lumen Loop surfaces audits but only as links; the trick is accurate summaries so Raven knows when an audit is relevant, then hands your agent the full source. Same pattern as Raven's planned ephemeral artifacts for oversized responses — just the right context at just the right time.
• Does Raven speak Spanish? Whatever your terminal speaks. The proxied APIs are mostly English semantic search, but your agent translates on both ends.
• Can we make a sassy Raven? Wrap it in your own agent and give it whatever personality you want — one of the crew confessed theirs answers as Princess Donut from Dungeon Crawler Carl. Mine calls me Mr. Kaan. I want professional distance from my agent.
• Is this a Stella replacement? Different animal. Tyler was blunt: Stella was a great experiment and he's glad it died — it made Discord unsearchable, a huge share of prompts were vandalism attempts or non-Stellar questions, and an agent-as-a-service collects PII you then have to worry about. Raven inverts the model: a service that your agent calls, with tool-use-shaped telemetry instead of raw prompts. My addition: Stella existed because models couldn't read our docs properly back then. Frontier models read docs fine now — the scarce thing is dynamic, current ecosystem context, and that's precisely what Raven addresses.

Tangents Worth Keeping

Building this stuff is not cheap: Tyler estimated around 20 billion tokens in the last couple of weeks alone. That led into a review of token-saving tools — headroom (compresses JSON and log output), caveman (make prose short, why speak much when few word do trick), and ponytail (don't over-engineer; less code when little code does the trick). Verdict: modern models are too smart to be talked to stupidly. Headroom-style compression made them suspicious they were missing something, so they looped and burned more tokens; caveman's brevity triggered extra reasoning to reconstruct the stripped context. Only ponytail earned its keep, and less for token savings than for code quality. If you're going to install one, install that one.

Best mini case study of the call came from Bri, who is building an application with confidential token transfers and used Raven as a research tool: "Alice owns 1,000 USDC, Bob owns 300; Alice deposits 500 into the confidential token wrapper and privately transfers 200 to Bob — walk me through step by step what happens." Raven's answer taught Bri more about confidential transfers than a week of reading. Researching with Raven is as legitimate a use case as building with it — and it's not a one-and-done oracle. Ask, learn a little, redirect, pair it with your other tools.

Closing

We peaked around 380 live viewers, blew past the hour as usual, and rolled into the protocol discussion half an hour later. Brazilian builders: we'll be at the Stellar Builder Summit in São Paulo — find me there and ask me about Raven. Otherwise, ask on the Discord or tag Tyler (@kalepail), Lumen Loop, Boxy, or Bri on X. Every question makes Raven better.

Also, I publicly demanded Raven swag. A bandana would be sick. Slogan's already written: just ask the Raven. See you next week.