---
title: "ARC 1.0"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/5317da8d-08a1-475a-9937-9a850d3d57e9"
updated: "2026-11-12"
---

# ARC 1.0

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Reads an agent's conversation and predicts which model will succeed, how many tokens it will use and how much reasoning to spend, so apps can route requests by quality and cost. For agent developers.

ARC 1.0 is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by rayline-ai

## About

### What it is

ARC, the Adaptive Routing Controller, is a small decision model that helps an AI agent pick which model should handle the next request. It reads the conversation and outputs signals, such as the chance a model will finish the task and how many tokens it will use. Your application combines those signals with its own model list, prices and policies. The weights are about 1.2 GB in BF16.

### Who it suits

Developers who run agents across several cloud and local models and want to balance answer quality against cost.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Agent platform teams | Choose the best model for each request from a pool | Send easy tasks to a cheap model and hard ones to a strong one |
| Cost control | Engineering managers | Set how much success is worth against spend | A cost-first policy for routine work |
| Privacy | Security teams | Detect sensitive information in the input before routing | Keep requests with personal data on a local model |
| Research | ML researchers | Study routing and compare routers on public benchmarks | Read the report's comparison with other routers |

You can skip it if you only ever call one model, since its job is choosing between models.

### Where to use it

It sits in front of an agent or a model gateway, and the Hugging Face record lists vLLM as its library.

- Agent applications that can call several models
- A vLLM server that hosts the controller
- Setups that mix cloud models with local ones

| Use case | Who | What they get back |
| --- | --- | --- |
| Model selection | Agent developers | A predicted success chance for each eligible model |
| Cost estimates | Platform teams | Expected token usage, from which you compute spend |
| Reasoning settings | Developers | The expected benefit and cost of each setting |

### How to set it up

You need Python with pip to fetch the weights, a vLLM serving setup and your own list of models with prices. The visible part of the card shows no run command.

- Python with pip
- A vLLM server for the controller
- Your model list, prices and routing policy

1. Install the Hugging Face download tool.
2. Download the ARC weights to your computer.
3. Serve them and connect the signals to your own routing policy, following the maker's documentation.

```bash
pip install -U huggingface_hub
hf download rayline-ai/ARC-1.0
```

### How to use it

Send the agent's conversation to ARC and read the signals back. Then apply your policy. The card's preset utility rule is value times predicted success, minus expected cost, and you choose the eligible model with the highest result.

| Tool | What it does |
| --- | --- |
| Model success signal | Gives each eligible model a predicted chance of completing the task |
| Token usage signal | Estimates input, cache and output tokens so you can price them |
| Reasoning signal | Weighs expected benefit and cost of each reasoning setting |
| PII detection | Reports whether sensitive information is present, and its types |
| Request categories | Labels the operations and domains a request involves |
| Question head | Returns probabilities for answer options you define |

### Example

Pass a request together with a question such as whether it needs a stronger model, with yes and no as the options. ARC returns a probability for each option, and your application uses them to pick a model.

### For newcomers and experts

Think of ARC as a dispatcher. Given a job, it estimates which worker is likely to do it well and what it will cost. A first small try is to run it on a few of your own requests and look at the success and cost signals.

For experts, ARC separates prediction from policy. It predicts success and token usage, and your application brings the prices, so a price change needs no retraining while the model and serving setup stay fixed. The Sage and Swift presets differ only in the value placed on success, 4.5 against 0.1. A preset states a preference, so realized quality and cost still depend on your requests and model pool.

An agent conversation arrives → ARC predicts success and token use → Your app adds prices and policy → The best eligible model is chosen → The request runs on that model

### Good to know

The figures below come from the maker's own technical report, and they cover the maker's chosen configurations.

- Hybrid result: Across six benchmarks the report's edge and cloud setup keeps 97.5 percent of Opus 5.5's quality while spending 92.9 percent less.
- Uneven wins: ARC Sage scored below Opus 5.5 on Tau3 Banking, 33.2 percent against 42.8.
- Presets: Sage values success at 4.5, Swift at 0.1, and a prefer-local setting uses a local model above a threshold you set.

ARC Sage cost as a share of Opus 5.5 cost

| Label | Value |
| --- | --- |
| DeepSWE | 7 percent |
| SWE-Atlas QA | 13 percent |
| Tau3 Banking | 17 percent |
| GPQA Diamond | 21 percent |
| MMMU-Pro Vision | 39 percent |
| Terminal-Bench 2.1 | 58 percent |

RouteBench mean routing index, out of 10

| Label | Value |
| --- | --- |
| ARC Sage | 9.3 points |
| Pareto | 9.2 points |
| ARC Swift | 9.1 points |
| Fugu Max | 7.1 points |

- License: Apache 2.0.
- Cost to run: none named for ARC itself, the source lists no API key or account, and the prices of the models you route to are yours to supply.
- Data it reaches: the conversations you send it, and it can flag sensitive information in them.
- Not for: chatting or writing text, since it outputs routing signals instead of answers.

## README

````markdown
# ARC 1.0

Reads an agent's conversation and predicts which model will succeed, how many tokens it will use and how much reasoning to spend, so apps can route requests by quality and cost. For agent developers.

Made by rayline-ai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: ARC, the Adaptive Routing Controller, is a small decision model that helps an AI agent pick which model should handle the next request. It reads the conversation and outputs signals, such as the chance a model will finish the task and how many tokens it will use. Your application combines those signals with its own model list, prices and policies. The weights are about 1.2 GB in BF16.

Who it suits: Developers who run agents across several cloud and local models and want to balance answer quality against cost.

```table
Industry | Who uses it | How they use it | Example
Software | Agent platform teams | Choose the best model for each request from a pool | Send easy tasks to a cheap model and hard ones to a strong one
Cost control | Engineering managers | Set how much success is worth against spend | A cost-first policy for routine work
Privacy | Security teams | Detect sensitive information in the input before routing | Keep requests with personal data on a local model
Research | ML researchers | Study routing and compare routers on public benchmarks | Read the report's comparison with other routers
```

You can skip it if you only ever call one model, since its job is choosing between models.

Where to use it: It sits in front of an agent or a model gateway, and the Hugging Face record lists vLLM as its library.

- Agent applications that can call several models
- A vLLM server that hosts the controller
- Setups that mix cloud models with local ones

```table
Use case | Who | What they get back
Model selection | Agent developers | A predicted success chance for each eligible model
Cost estimates | Platform teams | Expected token usage, from which you compute spend
Reasoning settings | Developers | The expected benefit and cost of each setting
```

How to set it up: You need Python with pip to fetch the weights, a vLLM serving setup and your own list of models with prices. The visible part of the card shows no run command.

- Python with pip
- A vLLM server for the controller
- Your model list, prices and routing policy

1. Install the Hugging Face download tool.
2. Download the ARC weights to your computer.
3. Serve them and connect the signals to your own routing policy, following the maker's documentation.

```bash
pip install -U huggingface_hub
hf download rayline-ai/ARC-1.0
```

How to use it: Send the agent's conversation to ARC and read the signals back. Then apply your policy. The card's preset utility rule is value times predicted success, minus expected cost, and you choose the eligible model with the highest result.

```table
Tool | What it does
Model success signal | Gives each eligible model a predicted chance of completing the task
Token usage signal | Estimates input, cache and output tokens so you can price them
Reasoning signal | Weighs expected benefit and cost of each reasoning setting
PII detection | Reports whether sensitive information is present, and its types
Request categories | Labels the operations and domains a request involves
Question head | Returns probabilities for answer options you define
```

Example: Pass a request together with a question such as whether it needs a stronger model, with yes and no as the options. ARC returns a probability for each option, and your application uses them to pick a model.

For newcomers and experts: Think of ARC as a dispatcher. Given a job, it estimates which worker is likely to do it well and what it will cost. A first small try is to run it on a few of your own requests and look at the success and cost signals.

For experts, ARC separates prediction from policy. It predicts success and token usage, and your application brings the prices, so a price change needs no retraining while the model and serving setup stay fixed. The Sage and Swift presets differ only in the value placed on success, 4.5 against 0.1. A preset states a preference, so realized quality and cost still depend on your requests and model pool.

```flow
An agent conversation arrives
ARC predicts success and token use
Your app adds prices and policy
The best eligible model is chosen
The request runs on that model
```

Good to know: The figures below come from the maker's own technical report, and they cover the maker's chosen configurations.

- Hybrid result: Across six benchmarks the report's edge and cloud setup keeps 97.5 percent of Opus 5.5's quality while spending 92.9 percent less.
- Uneven wins: ARC Sage scored below Opus 5.5 on Tau3 Banking, 33.2 percent against 42.8.
- Presets: Sage values success at 4.5, Swift at 0.1, and a prefer-local setting uses a local model above a threshold you set.

```chart
Title: ARC Sage cost as a share of Opus 5.5 cost
DeepSWE: 7 percent
SWE-Atlas QA: 13 percent
Tau3 Banking: 17 percent
GPQA Diamond: 21 percent
MMMU-Pro Vision: 39 percent
Terminal-Bench 2.1: 58 percent
```

```chart
Title: RouteBench mean routing index, out of 10
ARC Sage: 9.3 points
Pareto: 9.2 points
ARC Swift: 9.1 points
Fugu Max: 7.1 points
```

- License: Apache 2.0.
- Cost to run: none named for ARC itself, the source lists no API key or account, and the prices of the models you route to are yours to supply.
- Data it reaches: the conversations you send it, and it can flag sensitive information in them.
- Not for: chatting or writing text, since it outputs routing signals instead of answers.

## On Hugging Face, 13 November 2026

- Task: text classification
- Library: vllm
- Parameters: 615M
- Weights: about 1.2 GB in BF16; about 308 MB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 37
- Likes: 23
- License: apache-2.0
- Languages: en
- Based on: Qwen/Qwen3.5-0.8B
- Tags: vllm, safetensors, qwen3_5, rayline, model-routing, agents, decision-model, custom-code, text-classification

## Links

- Model: https://huggingface.co/rayline-ai/ARC-1.0
- Files: https://huggingface.co/rayline-ai/ARC-1.0/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download rayline-ai/ARC-1.0
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[rayline-ai/ARC-1.0 on Hugging Face](https://huggingface.co/rayline-ai/ARC-1.0)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| ARC 1.0 (this page) | 37 | 23 | 615M | apache-2.0 | 2026-11-10 |
| [OpenJev](https://mindket.com/p/173f3b2e-f55d-4777-9609-91685a1f0a12) | 9,293 | 199 | 27.4B | cc-by-nc-4.0 | 2026-10-09 |
| [pplx-decider-flash-v1.2](https://mindket.com/p/ba207a37-74ec-4e43-aa10-b746d0ba8d5a) | 7,052 | 78 | 4.5B | apache-2.0 | 2026-10-19 |
| [pplx-decider-v1.2](https://mindket.com/p/88a31af1-401b-4379-82f4-56dcfad230fc) | 5,700 | 74 | 26.1B | apache-2.0 | 2026-10-19 |
| [Mica-v0.5-4B](https://mindket.com/p/c2b0989e-391f-42fa-98d4-76dc182d0845) | 6,375 | 47 | 4.7B | apache-2.0 | 2026-10-28 |
| [clef-flash-4bit](https://mindket.com/p/f2c928d8-4190-4b0e-b8c5-534296134c5f) | 3,524 | 40 | 9.4B | apache-2.0 | 2026-10-08 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-10
- First published: 2026-11-10
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open rayline-ai/ARC-1.0 on Hugging Face](https://huggingface.co/rayline-ai/ARC-1.0)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/5317da8d-08a1-475a-9937-9a850d3d57e9)
- [Its page on Mindket](https://mindket.com/p/5317da8d-08a1-475a-9937-9a850d3d57e9)
