# Manifest — Smart LLM Router That Cuts Costs 70%

> Intelligent LLM routing that scores requests across 23 dimensions in under 2ms. Routes to the cheapest capable model among 300+ options from 13+ providers. MIT, 4,200+ stars.

## Install

Save the content below to `.claude/skills/` or append to your `CLAUDE.md`:

## Quick Use

1. Install via OpenClaw:
```bash
openclaw plugins install manifest
```

2. Or run locally with Docker:
```bash
docker pull mnfst/manifest
docker run -p 2099:2099 mnfst/manifest
```

3. Open dashboard at `http://127.0.0.1:2099` and configure your API keys.

---

## Intro

Manifest is a smart LLM router with 4,200+ GitHub stars that sits between your application and LLM providers. It scores each request across 23 dimensions in under 2ms and routes it to the cheapest model that can handle it — cutting costs up to 70% without quality loss. Supports 300+ models from 13+ providers (OpenAI, Anthropic, Google, DeepSeek, etc.) with automatic fallbacks and budget controls. Best for teams running production LLM apps who want to optimize API spending automatically.

See also: [AI developer tools on TokRepo](https://tokrepo.com/en/@AI%20Open%20Source).

---

## Manifest — Intelligent LLM Cost Optimization

### The Problem

Different LLM tasks have different complexity levels. Sending every request to GPT-4o or Claude Opus wastes money — many requests could be handled by cheaper models just as well.

### The Solution

Manifest analyzes each request's complexity and routes it to the cheapest model that meets the quality threshold. Simple tasks go to fast, cheap models. Complex tasks go to powerful ones.

### How It Works

1. **Request arrives** from your application
2. **23-dimension scoring** analyzes complexity (under 2ms latency)
3. **Model selection** picks the cheapest capable model
4. **Routing** sends to the selected provider
5. **Fallback** automatically retries with a different model if the first fails

### Key Features

- **300+ models** from 13+ providers
- **23-dimension scoring** in under 2ms
- **Up to 70% cost reduction** without quality loss
- **Automatic fallbacks** when models fail
- **Budget controls** — set spending limits per model, team, or project
- **Transparent decisions** — dashboard shows why each request was routed where
- **Direct provider access** — your API keys, no middleman markup

### Supported Providers

OpenAI, Anthropic (Claude), Google (Gemini), DeepSeek, Mistral, Groq, Together AI, Fireworks, Cerebras, and more.

### Deployment Options

| Option | Command |
|--------|---------|
| **Cloud** | Visit app.manifest.build |
| **Local** | `openclaw plugins install manifest` |
| **Docker** | `docker run -p 2099:2099 mnfst/manifest` |

### Cost Savings Example

| Scenario | Without Manifest | With Manifest | Savings |
|----------|-----------------|---------------|---------|
| Customer support bot | $500/mo (all GPT-4o) | $150/mo (mixed routing) | 70% |
| Code review agent | $800/mo (all Claude Opus) | $320/mo (mixed routing) | 60% |
| Data extraction pipeline | $300/mo (all GPT-4) | $90/mo (mixed routing) | 70% |

### FAQ

**Q: What is Manifest?**
A: A smart LLM router that scores requests across 23 dimensions and routes them to the cheapest capable model, cutting LLM API costs up to 70% without quality degradation.

**Q: Is Manifest free?**
A: The core router is open-source under MIT. Self-host for free or use the cloud version.

**Q: Does Manifest add latency?**
A: The routing decision takes under 2ms. Total added latency is negligible compared to LLM response times.

---

## Source & Thanks

> Created by [mnfst](https://github.com/mnfst). Licensed under MIT.
>
> [Manifest](https://github.com/mnfst/manifest) — ⭐ 4,200+

Thanks to the Manifest team for making LLM cost optimization accessible.

---

<!-- ZH -->

## Quick Use

1. Install:
```bash
openclaw plugins install manifest
```

2. Or Docker deployment:
```bash
docker run -p 2099:2099 mnfst/manifest
```

3. Open `http://127.0.0.1:2099` to configure API keys.

---

## Introduction

Manifest is a smart LLM router with 4,200+ GitHub stars. It sits between your app and LLM providers, scores each request across 23 dimensions (<2ms), and automatically routes to the cheapest capable model — saving up to 70% on cost. Supports 300+ models across 13+ providers, with automatic failover and budget controls. Ideal for teams running production LLM apps that want to optimize API spend automatically.

---

## Manifest — Smart LLM Cost Optimization

### How It Works

1. Request arrives → 23-dimension complexity scoring (<2ms)
2. Pick the cheapest sufficiently-capable model
3. Route to the chosen provider
4. On failure, automatically switch to a fallback model

### Core Features

- 300+ models across 13+ providers
- 23-dimension scoring, <2ms latency
- Up to 70% cost savings
- Automatic failover
- Budget controls
- Transparent decision dashboard

### FAQ

**Q: What is Manifest?**
A: A smart LLM router that scores requests across 23 dimensions and routes to the cheapest capable model — saving up to 70% on API cost.

**Q: Is it free?**
A: The core router is open source (MIT) and self-hostable.

---

## Source & Thanks

> Created by [mnfst](https://github.com/mnfst). Licensed under MIT.
>
> [Manifest](https://github.com/mnfst/manifest) — ⭐ 4,200+


---
Source: https://tokrepo.com/en/workflows/manifest-smart-llm-router-cuts-costs-70-15266cba
Author: AI Open Source