The control plane between your team and your LLMs.
Devtor routes each task to the right model, with the right context, at the right cost. No wasted compute. No configuration overload.
Hover to see the flow
A control plane between your team and every LLM
Devtor is an orchestration layer that optimizes cost, performance, and reliability by dynamically managing prompts, models, context, and execution strategies — continuously improving from past interactions.
It decides how, when, and which model to use. Engineering teams get terminal-first workflows, explainable routing, and production-grade guardrails without configuring a dozen provider dashboards.
Core promise
The right model, context, and execution strategy for every task.
- ✓Works with OpenAI, Anthropic, Google, Mistral, and local models
- ✓Terminal-first — no dashboard required to start
- ✓Hybrid super-agent + sub-agent architecture
- ✓Plan-first mode with pre-execution cost estimates
Intelligent routing
Every task is analyzed for complexity before inference. Devtor picks the cheapest model that can do the job correctly — not your default flagship.
Smart context
Only relevant files and messages reach each model call. No more paying to re-send entire chat histories on every follow-up.
Cost transparency
Token estimates and projected spend appear before execution. Approve, adjust, or cancel — never get surprised by agent loops.
Organizational learning
Resolved failures become shared knowledge. The next engineer — or agent — that hits the same wall gets the fix automatically.
End-to-end orchestration pipeline
See the three phasesOrchestration in three phases
Every task goes through a deliberate cycle. Devtor never blindly forwards your prompt to the most capable — or most expensive — model.
Plan First
Analyze before you infer.
Before touching a model, Devtor analyzes your task — estimating complexity, token usage, and the optimal execution path.
Every Devtor session starts with structured planning. Instead of sending your prompt straight to the most capable model, the orchestrator breaks down what you are asking for, what files matter, and what level of reasoning the task actually requires.
- Transparent cost estimates before execution
- Task complexity scoring drives better routing
- Context attachments chosen for relevance, not volume
Route Intelligently
Right model. Right price.
It selects the cheapest model that can handle your task correctly. Expensive models are reserved for tasks that actually need them.
Routing is where Devtor earns its name as a control plane. The orchestrator compares task requirements against a matrix of provider capabilities, latency, and price — then picks the minimum viable model.
- Automatic model selection per task type
- Expensive models only when complexity demands it
- Explainable routing logs for every run
Execute & Learn
Run once. Route smarter next time.
Runs the task, tracks actual spend against the estimate, and records the pattern — so the next similar task routes even faster.
Execution closes the loop: Devtor runs the approved plan, streams progress in the terminal, and compares actual token usage and cost against the pre-flight estimate.
- Actual vs. estimated cost tracking per run
- Pattern cache speeds up repeat task types
- Interactive think mode for mid-run corrections
Built for engineering teams
who take AI seriously.
These aren't features for a slide deck. Each capability addresses a real operational problem that teams face when running LLMs in production.
Hybrid Model Architecture
One super agent. Many cheap sub-agents. Automatically.
A high-capability orchestrator reasons about the task and delegates execution to lower-cost models. You get quality where it matters and efficiency everywhere else.
Problem: Teams default to a single flagship model for every task — burning budget on lint fixes, boilerplate, and lookups that cheaper models handle well.
- Orchestrator handles reasoning; workers handle execution
- Automatic delegation based on subtask complexity
Smart Context Window
Only pass what's relevant. Not the full conversation history.
Devtor compresses and filters session context before each inference call, eliminating token waste without losing continuity.
Problem: Long sessions balloon context windows. Every follow-up re-sends the entire chat history, multiplying cost and latency.
- Relevance scoring per message and file
- Smart compression for older session turns
Pre-Execution Token Estimation
Know the cost before you commit the compute.
Before running any expensive inference, Devtor surfaces a token estimate and projected cost. You decide whether to proceed.
Problem: Agent loops and build commands can trigger surprise bills. Teams discover cost only after the run completes.
- Token and cost breakdown per model option
- Approve or cancel before execution starts
Interactive Think Mode
Interrupt an agent mid-execution. Redirect. Continue.
Unlike black-box agent loops, Devtor exposes intermediate reasoning steps and lets you inject corrections before the agent finalizes its output.
Problem: Black-box agents run to completion before you can steer. Wrong assumptions waste minutes and tokens.
- Visible intermediate reasoning in the terminal
- Pause and redirect without full restarts
Skill Builder
Build, test, and benchmark custom agent behaviors.
Define reusable skills with evaluation modes and test suites. Fine-tune agent behavior against real benchmarks without guesswork.
Problem: Ad-hoc prompts do not scale across teams. Behaviors drift, and there is no way to regression-test agent output.
- Reusable skills versioned per team or repo
- Benchmark suites catch regressions early
Cross-User Learning
When one instance solves a problem, all instances benefit.
Failed tasks and their resolutions are stored and indexed. The next agent that hits the same wall retrieves the fix — across your entire organization.
Problem: Every engineer repeats the same agent failures. Fixes stay siloed in individual sessions.
- Indexed failures and resolutions across the org
- Automatic retrieval on matching task patterns
Terminal-first. Ready when you are.
Devtor runs from your terminal with your existing provider keys. No account wall. No dashboard to configure before your first orchestrated task. Installation commands are coming soon — preview the setup flow now.
Install the CLI
yarn, npm, or homebrew
Add provider API keys
Reads from your .env
Run devtor init
Auto-detects your codebase
Run your first task
Natural language in terminal
- Node.js 18+ and at least one LLM provider key
- OpenAI, Anthropic, Google AI, or Mistral supported
- Local models supported for offline workflows