--config and --thinking flags enable sophisticated multi-model workflows. Instead of using a single model for all tasks, you can route different work to different models based on cost, capability, and specialization.
Why Orchestrate Multiple Models?
Cost Optimization By routing work to the right model for the job, you can reduce API costs. Fast, inexpensive models like Haiku and Gemini Flash handle simple tasks such as summarization, while more expensive models like Opus are reserved for complex reasoning and planning. Bias Reduction Different models catch different issues, so cross-validating solutions with multiple AI perspectives helps reduce blind spots that come from relying on a single model. In code reviews especially, combining viewpoints surfaces problems that any one model might miss. Specialization Models differ in what they do well. Security analysis in particular benefits from combining several models, since each brings different training data and heuristics to the table.Pattern 1: CI/CD Code Review
The GitHub PR Review sample runs Cline CLI in GitHub Actions to review pull requests, except drafts and pull requests from forks or Dependabot. Itscline auth step picks the model, so you can give the review job a stronger model than the rest of your automation.
Pattern 2: Task Phase Optimization
Use different models for different phases of work. Route simple tasks to cheap models, complex reasoning to premium models.Example: Issue Analysis Pipeline
Without
--json, the CLI also prints the model’s thinking, and the next phase would read it as part of its input. --json with final_answer keeps only the answer. Each cline command must finish before the next phase starts, so store each result in a shell variable rather than piping one cline command into the next.When a run fails, cline exits with an error, but final_answer still prints the error message. set -euo pipefail stops the script there, so that the error message doesn’t become the next phase’s input.- Haiku 4.5: $1
- Sonnet 5.5: $2
- Opus 5.5: $4
Setting Up Model Configs
--config points Cline at a different configuration directory, and each directory keeps its own provider and model. Set up one directory per model:
--config:
Pattern 3: Multi-Model Review & Consensus
Get multiple AI perspectives on the same change, then synthesize their feedback.Example: Diff Review Pipeline
- Redundancy: Issues caught by all 3 models are high-confidence
- Coverage: Each model has blind spots; together they cover more ground
- Prioritization: Consensus issues should be fixed first
- Learning: See which model types catch which issue types
Advanced: Parallel Reviews
Run reviews in parallel for faster feedback:Each
cline command runs as its own process, so the reviews run at the same time. Give each one a different output file, as above, so that they don’t write over each other. wait on its own succeeds even when a review fails, so the script saves each review’s process ID as it starts and waits for each one. Don’t loop over jobs -p instead: in the bash 3.2 that macOS ships as /bin/bash, it leaves out reviews that have already finished, so a review that fails quickly would be missed.Extended Thinking for Complex Tasks
Use the--thinking flag when Cline needs to analyze multiple approaches:
--thinking <level> flag sets reasoning effort. Use --thinking high or --thinking xhigh when you want the model to spend more effort on complex tradeoffs. Best for:
- Architectural decisions
- Security analysis
- Complex refactoring
- Multi-step planning
Best Practices
- Profile your workload: Track which tasks are simple vs. complex
- Match models to tasks: Use fast models for summaries, powerful models for reasoning
- Automate switching: Script model selection based on task type
- Monitor costs: Different models have 10-100x price differences
- Validate important decisions: Use multi-model consensus for critical changes
Production Examples
Cost-Optimized PR Review
Security-Focused Multi-Model Scan
Related Documentation
CLI Reference
Complete documentation for —config and —thinking flags
Headless Mode
Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
Cline Provider
Fastest built-in model access setup and account workflow
CI/CD Integration
Automate GitHub workflows with Cline CLI