AtlasBurn
Paid
AI-native teams tracking variable inference costs
role-model
FreeOpen SourceAPISelf-Hosted
When you're running a mix of local Ollama endpoints and remote APIs, picking the right model by name is a guess — you have no record of why a request went where it did, and no policy layer to stop it from going somewhere it shouldn't.
Similar tools
AtlasBurnPaidAtlasBurn monitors token usage and cost distribution across OpenAI, Anthropic, Gemini, and AWS…
Selfship.aiPaidThe observe-diagnose-fix-verify cycle runs on live traffic without you assigning tasks or…
AgentmetryFreeAgentmetry is an open-source, local-only session recorder for AI coding agents — Cursor, Claude…
SemelbaseFreemiumThe vendor positions Semelbase as a ledger and routing layer that sits between your agents and…
Get This Tool
License: License: unverified
Local-run terms: Install and run the packaged router runtime locally from GitHub Releases after connecting endpoints and running benchmarks.
Pricing
- Model
- Free
Summary
role-model is an open protocol and reference router runtime that routes LLM requests across endpoints using declared capability profiles, routing policy, and measured performance — then emits a structured decision artifact you can inspect after the fact. The router narrows candidates by role and task metadata, rejects endpoints that fail capability, locality, or budget checks, and scores what's left against latency, cost, and reliability evidence. The decision is deterministic enough to audit, not a hidden runtime guess. The baseline role set covers chat, code editing, code review, tool calling, and embeddings — so it fits mixed-workload deployments out of the box. Teams needing autonomous multi-step planning or tool loops will find this deliberately out of scope.
Bottom line: Pick this when you need auditable, policy-driven routing across a mixed local-and-remote LLM fleet — skip it when what you actually need is an agent that decides what to do next, not just where to send a request.
Find your fit
Before you choose role-model
More options in LLM Observability. Compare pricing, platforms, and features side by side.
Agentmetry
Free · Open source
SOC and DevSecOps teams
Pros
- Explainable RouterDecision artifacts — including the chosen endpoint, fallbacks, exclusions, and named selection reasons — so when a routing call looks wrong, you have evidence to debug rather than a guess to reverse-engineer.
- Hard eligibility checks across capability, locality, budget, and binding requirements before scoring begins, which means a request that must not leave your network cannot accidentally route to a remote endpoint under load.
- Scoring uses measured performance evidence first and declared data second, so a local model that has been benchmarked beats a remote model that merely claims low latency — without you having to manually tune weights.
- Canonical schema definitions for every artifact in the protocol, so swapping a provider or redeploying to a different host doesn't silently change routing behavior or break downstream log parsing.
- OpenAI-compatible discovery interface for downstream clients, which means existing tooling that already speaks the OpenAI API format can connect without a custom adapter layer.
Cons
- role-model has no agent loop — it routes a request to an endpoint, it does not decide what the next request should be. Teams building systems where the model output determines the next action will need a separate orchestration layer, and the boundary between the two systems requires explicit wiring and maintenance.
- The baseline role taxonomy covers the documented set of general chat, code editing, code review, tool calling, and embeddings — workloads that fall outside those role IDs require teams to define custom role and capability profiles against the protocol spec, which adds schema work before the router is useful.
- There is no managed cloud runtime. The packaged reference runtime runs self-hosted, which means infrastructure ownership, upgrade management, and observability pipeline setup land on the team deploying it. Teams that hit operational overhead they didn't budget for tend to move toward a hosted LLM gateway product with a UI instead.
About
- Platforms
- Local runtime with operator UI
- API Available
- Yes
- Self-Hosted
- Yes
- Last Updated
- June 30, 2026
Best For
Who it's for
- Multi-provider LLM setups needing explainable routing
- Teams requiring policy-driven endpoint selection
- Environments with mixed local and remote models
What it does well
- Routing requests across local and remote LLM endpoints by role and capability
- Inspecting router decisions and selection reasons
- Benchmarking endpoint performance before choosing strategies
- Integrating with downstream clients via OpenAI-compatible discovery
Integrations
Frequently Asked Questions
- Is role-model free?
- role-model offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
- Is role-model open source?
- Yes. role-model is open source.
- Does role-model have an API?
- Yes. role-model exposes a developer API. See the official documentation at https://role-model.dev for details.
- Can I self-host role-model?
- Yes. role-model supports self-hosting on your own infrastructure.
- What platforms does role-model support?
- role-model is available on: Local runtime with operator UI.
Curated lists that include this category
Most LLM routing layers pick a model by name and move on — there’s no record of the decision, no capability check, no policy that prevents a cost-sensitive request from hitting a premium endpoint by accident. role-model is an open protocol and packaged reference runtime that fixes the audit gap. A request declares its task type, required capabilities, modalities, and tool needs. The router builds a policy snapshot, narrows the candidate endpoint set, applies hard eligibility checks across capability, locality, and budget, scores what survives using measured performance data first and declared profiles second, and returns a RouterDecision artifact that names the chosen endpoint, the fallbacks, the exclusions, and the selection reasons. Nothing is hidden.
The differentiating feature is the protocol layer itself. Endpoint identity, declared capability profiles, observed performance profiles, roles, tasks, routing policy, and the decision artifact are all defined as canonical schemas — not opaque runtime state. The docs describe a full reason code and rejection taxonomy, which means when an endpoint is excluded, you get a code you can grep for, not a log message you have to interpret. That makes the system portable: the same routing logic travels with you across provider changes, host changes, and deployment topology changes.
The baseline role set — general chat, patch-oriented code editing, code review, tool calling, and text embeddings — covers the workloads most mixed-model deployments actually run. The vendor states integration with Pi via a dedicated package and a /role-model setup flow, and the runtime exposes an OpenAI-compatible discovery interface for downstream clients. Where this breaks: role-model is a routing and observability layer, not an agent runtime. If your use case requires a system that decides what sequence of steps to take — not just which endpoint handles a known request type — you are looking at the wrong tool and will need a separate orchestration layer on top.
Contribute
- Work on role-model? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.