Revenant Research

IP & Tech

Relu

Built for the company. Not the developer.

OpenRouter is the unified interface for every model: five hundred models, one key, and a developer who has to choose. Relu is the unified interface for a company. A product asks Relu for a job by name: write this, find that, read this file. Relu picks the model, checks the request fits before it is sent, switches providers when one is down, and records what each job cost. Nobody at the company picks a model, maintains a fallback list, or gets paged when a provider changes its limits.

Jobs
32
Providers
6
Models in the catalog
55
Result format
1

The choice

A menu for developers, or a system for companies.

OpenRouter is marketed to developers. Five hundred models, eighty providers, one key, and the promise that you can choose anything. That is a fine product for a developer who wants to choose. It leaves the company holding the choices: which model, which fallback, which price, and who notices when a provider changes something on a Tuesday.

Relu is built for the companies we run. Their teams do not choose models, write fallback logic, or track provider price changes. Relu does that once, for all of them.

OpenRouter · sold to developers You choose.
Open aggregator topology Your product sends a request through one API key that fans out to hundreds of models. The developer wires the model, the fallback, the price, and what to do when one breaks. When a provider changes, the product changes. The developer wires: which model which fallback which price what to do when one breaks Your product One key every model 500+ models · 80+ providers each one the developer's to maintain When a provider changes, the product changes.

One key, every model. The developer chooses the model, the fallback order, and the price-versus-speed trade. The company owns the consequences when any of them changes.

Relu · built for companies Relu chooses.
Relu topology Your product names one of thirty-two jobs. Relu admits the request against the model budget, passes it through a gateway that tracks limits and circuits, fails over to the next route when one is down, and returns one envelope with cost attached. Six providers sit behind it and the product never sees them. When a provider changes, the registry changes and the product does not. The company decides: what it needs done Your product 32 jobs write this find that read this Relu Admission fits the budget? Gateway limits, circuits Failover next route Result one format, cost OpenAI Anthropic Gemini Groq Exa ElevenLabs 6 providers · 55 models the product sees none of them When a provider changes, we update Relu. No product changes.

One key, thirty-two jobs. Relu picks the model behind each one. When a better model comes out, we change one file in Relu and every company gets it. No product code changes.

Side by side

OpenRouter and Relu, side by side.

What each one is, what it does, and what that means for the company using it.

OpenRouter Relu
What it is

500+ models and 80+ providers behind one key.

32 named jobs and 6 providers behind one key. The request never names a model.

What it does

Lets a developer call any model through one key. The developer wires the fallbacks, budgets, and prices.

Picks the model for each job. Checks the request fits before sending it. Switches providers when one fails. Returns one result format with the cost attached.

What happens when things change

When a model improves or a provider fails, the developer has to decide again and ship a change.

When a model improves, every company on Relu gets it the same day with no code change. When a provider fails, the job runs on another one and the product never sees the failure.

What your team does

Your developer picks the model, writes the fallback logic, sets the budgets, and fixes all of it when a provider changes.

Nobody at your company picks models, writes fallback logic, or watches provider limits.

What you get

Every model, available to any developer.

Your engineers work on your product. Relu handles every model decision for them.

For a developer who wants every model, OpenRouter is the better tool. For a company that wants its engineers working on its own product, Relu is. They look alike in what they are. They differ in what you get.

How it works

How one request moves through Relu.

Every call works the same way: name a job, send the inputs, get a ticket back, check the ticket for the result. What happens in between is below. None of it is code the company has to write.

  1. Name the job

    Ask for “Write polished content” and hand over the brief. There is no model field.

  2. Admission

    Relu checks that the request fits the model before sending it. A duplicate of a job already running is not run twice.

  3. Queue

    The product gets a ticket back immediately. Workers pick the job up by priority. Long jobs report progress while they run.

  4. Gateway

    Every provider call goes through one checkpoint. Relu reads each provider's rate limits from the provider's own responses, so the limits stay current. A provider that fails three times in a row is paused for five minutes while the others take the work.

  5. Failover

    The default provider goes first. If it is down, rate limited, or paused, the next one on the list tries, then the next. If every provider for the job is out, a related job that can do the work takes it. The product's code does not change.

  6. One result format

    Whichever provider did the work, the result comes back in the same format: the output, any files, the tokens used, and the cost in dollars, recorded against the company and the job.

A better model ships With OpenRouter, each product's developer evaluates the new model, edits code, and deploys, one product at a time. With Relu, one line changes in Relu's registry and every product gets the new model the same day with no code change. OpenRouter one change per product New model ships developer evaluates edits code deploys product 1 · when its developer gets to it developer evaluates edits code deploys product 2 · when its developer gets to it developer evaluates edits code deploys product 3 · when its developer gets to it Relu one change, every product New model ships one line in Relu's registry Meridian Ghostrun every product on Relu Same day. No product code changes. The default model for each job is a field in the registry, not a line in any product.
A better model ships. With OpenRouter, each product's developer has to evaluate it, change code, and deploy, one product at a time. With Relu, we change one field and every product is on the new model the same day.
A failover, drawn out A request to write polished content tries Anthropic first, finds that route cooling down, and is served by OpenAI instead. If every provider had been out, the job would have been handed to the everyday-questions job. Write polished content the job, as the product asked for it Anthropic · Claude Sonnet 5 failed 3 times · paused 5 minutes OpenAI · GPT-5.6 did the work · 1,841 tokens · $0.0091 one result same format either way what the company saw: one ticket, one result if every provider is out: “Answer everyday questions” takes the job
A failover, drawn out. The product asked for polished writing. The first provider was paused after repeated failures, so the second one did the work. The result came back in the same format either way.

What Relu decides

Opinions, written down.

These are the decisions Relu makes for every company, so that no company has to make them itself.

  1. We will not hand a company a menu of five hundred models and call it freedom.

    We will give it thirty-two jobs with plain names and pick the model behind each one.

  2. We will not let a request fail on a limit nobody could see.

    We will size every request against the real model budget before it is queued, and say what would fit when it does not.

  3. We will not make one provider's outage our customer's outage.

    We will trip the failing route, move the job to the next provider, and keep the caller's code exactly as it was.

  4. We will not return six result formats for six providers.

    We will return one format, with tokens and cost on it, whichever provider did the work.

  5. We will not ship a feature that can break a call.

    We will build every add-on so that if it fails, the job still runs as if the add-on were not there.

  6. We will not change a product to change a model.

    We will change one file in Relu. When a better model comes out, every company on Relu gets it the same day.

The routing table

Which provider does which job.

The general-purpose jobs, every provider that can run each one, and the order Relu tries them in. A filled mark is the default. A hollow mark is a failover. An empty cell means we do not use that provider for that job. The table comes from the live system, so it shows what Relu does today.

JobOpenAIAnthropicGeminiGroqExaElevenLabs
Language
Answer everyday questions
Write polished content
Revise an existing document
Synthesize research findings
Solve complex problems
Process text quickly
Write and debug code
Analyze business decisions
Extract structured data
Web and search
Search the live web
Find people by role or company
Find recent news
Find companies
Find places and local info
Research a topic across websites
Compare multiple web sources
Analyze a specific webpage
Read a webpage or PDF link
Complete a task in the browser
Documents, data, and code
Search uploaded documents
Understand text images and audio
Analyze data with Python
Run code in a secure container
Analyze a PDF document
Turn text into search vectors
Media
Create or edit an image
Convert text to speech

Where it runs

What the companies get.

Meridian and Ghostrun both run on Relu. Neither team chose a model, wrote fallback code, or set a token budget. Relu made those decisions once for both of them, and their engineers spent that time on their own products.

Relu is not sold on its own. It is why a provider outage never shows up in a Meridian chat, and why a Ghostrun workflow built this quarter still runs next quarter.

Built in house, kept in house. Relu is core IP of Revenant Research. See the companies and products that run on it.