AskCodi Free

AskCodi is a local-first AI programming engineering team product. The core is a CTO Agent that breaks down requirements into tasks and assigns front-end, back-end, testing, security and other specialized agents to develop in parallel in an isolated git worktree, and merge after mutual review. Supports 50+ models (OpenAI, Anthropic, Google, xAI, Meta, DeepSeek, etc.), and provides three entrances: desktop Web Chat and OpenAI compatible API.

Full review of #AskCodi

Core parameters and statistics

AskCodi's official positioning is not "another AI code completion plug-in", but an AI engineering team running natively. It uses the CTO Agent to break down requirements, assigns specialized Agents (front-end, back-end, testing, security, etc.) according to task types to develop in parallel in an isolated git worktree. After completion, they review each other and then merge - the entire process imitates the collaboration model of a real team.

Projects	Public Information
Official positioning	An AI engineering team on your machine
Core form	CTO Agent + Expertise Agent Swarm + Isolation git worktree
Deployment method	Local desktop (Mac/Windows/Linux), supplemented by Web Chat
Model coverage	50+ models (OpenAI, Anthropic, Google, xAI, Meta, DeepSeek, etc.)
User scale	400,000+ monthly active users
Latest version	0.0.83 (2026-06-28, desktop)
Code Visibility	100% local execution, code never leaves the machine
Entry form	Desktop App, Web Chat, OpenAI compatible API
Business model	Free application + paid subscription based on Token usage

Parameter Interpretation: The key difference between AskCodi and Copilot or Cursor is the "orchestration level" - it is not a single Agent generating code in a single folder, but multiple Agents collaborating in parallel branches. Its CTO Agent not only disassembles requirements, but also automatically selects the cheapest competent model based on the nature of the task (such as Haiku for reconstruction, Sonnet for new features, and Opus only when necessary) to control Token consumption.

User and market recognition

AskCodi’s official website claims to have 400,000+ monthly active users, covering individual developers, entrepreneurial teams to medium-sized enterprises. Its GitHub release warehouse (Assistiv-AI/askcodi-releases) hosts desktop distribution and update logs, but the warehouse itself is only used for releases and is not public as the main development warehouse, so there is no public stars/forks data as a community popularity indicator.

Market positioning: AskCodi cuts into a unique segment in the "AI coding assistant" track - multi-agent orchestration + local priority. Different from Cursor's IDE built-in experience, Copilot's editor completion, and open source single-agent solutions such as Cline/Continue, AskCodi is closer to "running an AI development team on your machine." Its public blog has conducted multiple comparative analyzes with Sakana Fugu, Claude, etc., showing that it is positioned in "transparent multi-model orchestration" rather than a black-box unified API.

Third Party Signal: The public blog content is of high quality and involves in-depth topics such as AI Agent cost trend benchmark, limitations, MCP ecology, etc., indicating that the team has strong technical influence building capabilities. However, independent reviews or third-party benchmark rankings from leading technology media have not yet been observed.

Cost advantage

AskCodi's cost structure is divided into three tiers, covering individual API developers and team collaboration scenarios.

C client/individual users:

• Desktop and Web Chat Free to download and use.
• Free plan: $0/month, unlimited use of free models + 100K one-time Premium model tokens.
• Starter plan: $20/month, 16M Token/month, covering all models + custom Agent + orchestration capabilities.
• Pro plan: $100/month, 80M Token/month, priority support + multiple workspaces.
• Max plan: $200/month, 160M Token/month, maximum rate limit + priority routing.
• 17% discount when paying annually.

API/Developer:

• OpenAI compatible APIs are billed on a per-model basis, and the price per million Tokens varies by model (you need to check the exact input/output rates in the /models directory).
• Supports BYOK (Bring Your Own Key), you can connect your own Claude or OpenAI subscription, and it will not be counted in the AskCodi quota consumption.
• The free tier provides a small monthly token bonus for experimentation.

Business/Team:

• Enterprise pricing is not disclosed, please contact the business owner for confirmation.
• Supports multiple workspaces (Pro and above), inviting members, and custom model configuration.
• Detailed terms for auditing and compliance-related functions have not been disclosed.

Hidden Cost: The 100K one-time Tokens in the Free plan are available only when used up. Subsequent use of the Premium model requires an upgrade fee; the free model is limited (subject to the official list). Although BYOK is supported at the API level, it needs to be forwarded through the AskCodi gateway, which has additional latency overhead. In addition, the desktop side currently mainly provides macOS ARM version, and whether the Windows and Linux versions are functionally equivalent needs to be verified.

Main functions

• CTO Agent Orchestration: core differentiating capabilities. Users describe their requirements in natural language, and the CTO Agent automatically breaks them down into executable tasks and assigns them to specialized agents based on task type (front-end, back-end, testing, security, documentation). The CTO has exclusive control of done permissions, and the engineer agent is prohibited from self-approval of mergers at the MCP layer.

• Isolated Git Worktree parallel development: Each specialty Agent works in an independent git worktree without interfering with each other. Automatically symlink node_modules and other dependencies between worktrees to avoid repeated installation. Supports dependency-aware scheduling (blockedByIssueIds), and blocked Agents are automatically skipped.

• Pre-merge test gating: Automatically trigger test running (automatically detect bun/pnpm/yarn/npm) before code merging, and merge only after the test passes. The review agent is automatically generated and automatically awakened when the code enters the in_review state.

• Unified entrance for 50+ models: Call 50+ models such as OpenAI (GPT-5, o3, GPT-4o series), Anthropic (Claude 4.5 Sonnet/Opus/Haiku), Google (Gemini 2.5 Pro/Flash), xAI (Grok 4), Meta (Llama 4), DeepSeek (V3/R1), etc. through one API Key. Supports automatic routing to the cheapest competent model by task.

• OpenAI compatible API + custom Agent: Provides api.askcodi.com endpoint, compatible with OpenAI SDK format, supports stream, tool calling, vision, audio/TTS. Custom Agents (bundled prompt words + Skills + MCP tools) can be created and reused in Chat, IDE, and API.

• IDE integrated ecosystem: Supports mainstream IDEs such as Cursor (Override Base URL), VS Code (Continue/Cline/Roo Code), JetBrains, Neovim, Zed, Windsurf, etc., and can be accessed by configuring API endpoints.

Expert view: These six functions are not listed independently - the disassembly capability of the CTO Agent is the entrance, the git worktree isolation is the engineering guarantee, and the test gating is the quality check. The three form a "disassembly→build→acceptance" relationship. Model unified entry and IDE integration allow this closure to be embedded into any existing development workflow without requiring users to migrate IDEs. What is really solved is the problem of "who is responsible for the final output when multiple AI Agents collaborate" - the CTO is the only human authorization merging point.

Model and version evolution

AskCodi's version evolution is divided into two lines: Desktop version line (0.0.x) and Platform version line (1.0.x). The desktop version is the current main product line, with extremely fast iterations (10+ versions since its release at the end of May 2026).

Desktop mainline (0.0.x)

Version	Date	Core Changes
0.0.83	2026-06-28	Optional routing telemetry to collect CTO decision-making data
0.0.82	2026-06-26	Honest model display, cost tracking, multi-workspace optimization
0.0.79	2026-06-04	Project folder path recovery
0.0.78	2026-06-04	Major reconstruction of the orchestrator pipeline: per-issue worktree, dependency scheduling, test gating, review agent
0.0.77	2026-05-27	Incremental fixes
0.0.76	2026-05-27	Incremental fixes
0.0.75	2026-05-26	Incremental fixes
0.0.74	2026-05-26	Apple passed the notarization to fix the first startup security warning

Platform verification line (1.0.x)

Version	Date	Core Changes
1.0.15	2026-05-30	AskCodi Desktop officially released
1.0.14	2026-05-15	Web Chat major update: per-chat model/Key, prompt vocabulary Skill/MCP mounting, split-screen comparison
1.0.13	2026-03-21	Agent Builder + Marketplace online
1.0.12	2026-03-20	High-efficiency inference model integration
1.0.11	2026-03-06	Frontier Model 2026 Update
1.0.10	2026-01-07	MiniMax M2.1 Integration
1.0.9	2026-01-07	GLM-4.7 integration
1.0.8	2025-11-26	Claude Opus 4.5 support
1.0.6	2025-11-17	Free model online
1.0.0	2025-09-08	Major platform reconstruction: API-first architecture, zero markup and transparent pricing

Evolutionary context: AskCodi started with the platform reconstruction in September 2025, first building a model aggregation layer (1.0.0~1.0.6), then adding Agent construction capabilities (1.0.13), and finally delivering a complete multi-Agent orchestration experience in Desktop form at the end of May 2026. The orchestrator pipeline reconstruction in desktop version 0.0.78 marks a qualitative change from "single-agent chat" to "multi-agent collaboration".

Technical advantages

Mechanism -> Effect -> Applicable Scenarios Cause and Effect Chain:

1. CTO Agent dismantling + model routing: After receiving the requirements, the CTO Agent uses the planning capabilities of the large model to split the tasks, and automatically routes to the lowest-cost competent model based on the nature of each subtask (refactoring, new features, testing, security review). The effect is to save 30%-70% of Token consumption compared with a single model call (official claim, actual test to be verified). The applicable scenario is daily development that requires frequent iterations, especially budget-sensitive individuals/small teams.

2. Isolated Git Worktree architecture: Each Agent has an independent git worktree, and cooperates with the cross-worktree node_modules symlink to achieve true parallel development without file conflicts. The effect is that multiple Agents can work at the same time without blocking each other. Applicable scenarios are medium and large projects involving front-end and back-end joint debugging and parallel modification of multiple modules.

3. Dependency-aware scheduling + review gate control: Agents express dependencies through blockedByIssueIds / linkIssues, and the scheduler dispatches them in topological order; after completion, the test is automatically triggered, and the review agent reviews it and merges it with the CTO. The effect is to solve the problems of "who waits for whom" and "who is responsible for quality" in multi-Agent collaboration. The applicable scenario is team collaboration projects that have a threshold for code quality.

4. Full local execution: All code processing is completed on the user's machine without leaving the machine. The effect is to eliminate the risk of code leakage and meet enterprise data compliance requirements. The applicable scenarios are finance, medical, government and other industries that have strict requirements on data sovereignty.

Comparison advantages: Compared with Cursor's Tab/Agent mode, AskCodi's worktree isolation allows it to handle a larger range of parallel modifications; compared with single-agent tools such as Claude Code / Cline, AskCodi has a clear division of labor and acceptance mechanism; compared with pure API aggregation layers such as OpenRouter, AskCodi provides complete engineering orchestration capabilities in the upper layer.

How to use

Three entrances

Entrance	Applicable scenarios	How to obtain
Desktop App	Daily development, multi-Agent orchestration, complete engineering experience	GitHub Releases download (mainly Mac ARM)
Web Chat	Quick Q&A, model comparison, light usage	Browser access chat.askcodi.com
OpenAI compatible API	IDE integration, automated pipeline, custom application	Configure endpoints after generating API Key

Get started quickly on desktop

1. Download and install AskCodi Desktop from GitHub Releases (currently available in macOS ARM version).
2. Start the application and log in with your GitHub/Google account.
3. Add a model Provider Key (such as Claude API Key or OpenAI API Key) in the settings, or directly use the unified API Key provided by AskCodi.
4. Open a local project folder.
5. Describe the requirements in CTO Chat, such as "Add a user authentication module, including JWT login and role middleware, to this Express application."
6. The CTO Agent automatically disassembles tasks and assigns expertise Agents to start working in the isolated worktree.
7. Track progress, review diffs, and approve merges through CTO Chat.

API quick access

curl https://api.askcodi.com/v1/chat/completions \
  -H "Authorization: Bearer $ASKCODI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-4.5-sonnet",
    "stream": true,
    "messages": [{"role": "user", "content": "Refactor this auth flow"}]
  }'

Just point base_url to https://api.askcodi.com and replace the API Key to use it in any OpenAI SDK-compatible tool.

Technical architecture link

User (requirement description)
    ↓
CTO Agent (LLM: Teardown + Routing)
    ├── Front-end Agent (worktree A) ──→ Code + Test
    ├── Backend Agent (worktree B) ──→ Code + Test
    ├── Test Agent (worktree C) ──→ Integration Test
    └── Security Agent (worktree D) ──→ Security Review
            ↓
    Review Agent (Automatic Code Review)
            ↓
    CTO approves merger (only done authority)
            ↓
    Master branch merge completed

Engineering Pitfall Guide

1. Dead-end loop and token explosion: In a multi-Agent scenario, the model may fall into an infinite loop of "repair → discover new problems → repair again". The solution is that the CTO Agent has built-in max_steps/timeout control, and the engineer Agent is prohibited from self-approval done at the MCP layer. It is recommended that users manually monitor the step count in CTO Chat for complex requirements and proactively intervene when the expected number of steps is exceeded.

2. Worktree quantity expansion: A worktree is created for each issue, and a large number of residual worktrees may accumulate after long-term iterations of the project. 0.0.78 has included startup-time orphan worktree garbage collection (GC), but periodic manual cleanup is still recommended. You can run git worktree prune in the project root directory to assist with cleanup.

3. Model routing black box: The model selection logic of CTO Agent is partially transparent to users. Only in 0.0.82 did the real model allocation and token consumption begin to be displayed on the dashboard. It is recommended that Pro users and above turn on detailed routing logs in key projects, regularly audit whether model allocation is in line with expectations, and avoid low-cost models being used for tasks that require high inference depth.

Product Pricing

AskCodi implements a "free application + paid subscription" model and does not lock in model suppliers.

Plan	Monthly Fee	Token Quota	Core Differences
Free	$0	Unlimited free models + 100K one-time Premium Token	Getting started, community support
Starter	$20	16M Token/month	All models + Custom Agent + Orchestration
Pro	$100	80M Token/month	Priority support + multiple workspaces
Max	$200	160M Token/month	Maximum rate limit + priority routing

• Save approximately 17% by paying annually.
• API is billed on a per-model basis and operates independently of subscription plans.
• BYOK (bring your own Key) does not consume subscription credits and is suitable for users who already have Claude/OpenAI subscriptions.
• For enterprise customized solutions, please contact the business owner to obtain a quotation.

Pricing logic: AskCodi's subscription essentially buys "Token quota + rate priority", not model access rights - the Free plan can also use the Premium model (consuming one-time Token or BYOK). This is different from other AI programming tools that charge per seat, and is more suitable for teams with large fluctuations in token usage.

Application scenarios

• Multi-module parallel development: When a requirement involves front-end UI, back-end API, database migration and test cases, the CTO Agent assigns four specialty agents to develop in parallel in an independent worktree, compressing serial hours of tasks into minutes. Key points to verify: Whether the dependency definition is accurate and whether the blockedBy configuration covers all preconditions.

• Daily refactoring and technical debt cleanup: CTO Agent automatically identifies refactoring opportunities in the code, allocates Haiku or Sonnet-level models to perform low-cost refactoring, and automatically triggers test verification after completion. Key points of verification: Comparison of test coverage before and after refactoring, and whether the CTO accurately identified hot paths that should not be refactored.

• AI Assisted Code Review: The review agent automatically wakes up when the code enters the in_review state, reviews diffs, runs tests, and marks potential issues. Verification focus: Review the Agent's false positive rate (marking code that actually does not need to be modified) and false negative rate (missing real bugs).

• Cross-IDE model gateway: Through OpenAI compatible API, use AskCodi as a multi-model unified gateway to connect to IDEs such as Cursor, VS Code (Continue/Cline), JetBrains, Neovim, Zed, etc. Key points to check: streaming response latency, tool call compatibility, and behavioral differences with native APIs.

Applicable people

• Independent developers and small teams (2-10 people): AskCodi's CTO Agent + multi-specialty Agent model is equivalent to "hiring an AI development team leader for free" and is suitable for teams that do not have full-time Code Review and architecture planning resources. But please note: the disassembly quality of the CTO Agent depends on the clarity of the initial requirements description. Fuzzy requirements will cause the Agent to idle.

• Developers in industries sensitive to data sovereignty: In industries such as finance, medical care, and government where data cannot be taken offline, cloud services such as Codeium are not available. AskCodi’s fully local execution feature is a must-have. Prerequisite: The local hardware must meet the computing power requirements for concurrent operation of multiple models (memory ≥ 16GB is preferred).

• Multi-model comparison and selection engineer: Technical selector who needs to compare the coding performance of different models (such as Claude Sonnet vs GPT-5 vs DeepSeek R1) in actual projects. AskCodi’s model unified entry and per-chat model selection reduce switching costs. Not suitable for boundaries: The value of AskCodi lies in multi-Agent orchestration. If you just "change the model to chat", it is more lightweight to use OpenRouter or native API directly.

• Unsuitable people: Developers who need real-time AI completion (Tab completion) in the IDE - AskCodi currently does not provide Copilot-style line-by-line completion; Enterprises that require highly customized Agent logic - Customized Agents currently have limited capability boundaries, and complex business logic still needs to be hard-coded; API consumers who pursue the lowest latency - Multi-model gateways have additional forwarding delays.

Summary and Outlook

AskCodi's product positioning is unique and clear - it is not a "smarter code completion", but an "AI development team running natively". Its combination of CTO Agent + isolation worktree + test gating is superior to most current single-agent solutions in terms of reliability of multi-agent collaboration. The figure of 400K+ monthly active users also shows that there is real demand in this direction.

Current Limitations:

• The desktop version is currently based on macOS ARM, and the functional equivalence of the Windows/Linux version needs to be verified.
• The disassembly quality of CTO Agent is highly dependent on the clarity of requirement description. Complex business requirements may require multiple iterations to obtain reasonable task decomposition.
• The model routing logic lacks a transparent audit panel (cost tracking was only added in 0.0.82).
• The community ecosystem (Skills/MCP tools in the Marketplace) is still in its early stages, with few third-party contributions.
• Lack of independent third-party benchmark data, official performance claims need to be independently verified.

Procurement/Adoption Risk Assessment: Individual developers can experience it at zero cost from the Free plan and pay attention to the disassembly accuracy of their own project types by the CTO Agent. For small teams, it is recommended to start with Starter and focus on verifying the actual efficiency improvement of worktree parallel development in projects with 3-5 people. Enterprise users need to first confirm the compatibility of the desktop in the enterprise environment (Windows, MDM policy, network proxy), and ask the business to provide detailed instructions for data processing - although the official claim is 100% local execution, routing telemetry (new in 0.0.83) and model API calls involve network requests, and it is necessary to confirm which data is offline and which resides locally. Focus on how black-boxed model routing is - current CTO model selection cannot be completely covered manually, and mission-critical recommendations are combined with BYOK fixed model versions to reduce uncertainty.

Related tools: github-copilot, cursor

Version Info

• AskCodi Desktop 0.0.83 ：Added anonymous optional routing telemetry to collect CTO routing decision data to disclose real savings figures; the EU/UK region is turned off by default and requires user consent to enable it. （2026-06-28）
• AskCodi Desktop 0.0.82 ：Honest model display - the CTO chat head previously displayed Opus when engineers were using Sonnet, which is now fixed; cost tracking for each conversation round has been added; multi-workspace experience optimization. （2026-06-26）
• AskCodi Desktop 0.0.79 ：Support for recovering paths from moved/renamed project folders; fix spawn ENOENT errors caused by missing cwd. （2026-06-04）
• AskCodi Desktop 0.0.78 ：Major updates to the orchestrator pipeline - per-issue git worktree, cross-worktree sharing node_modules, dependency-aware scheduling, pre-merge test gating, review agent automatically generates CTO exclusive done permissions. （2026-06-04）
• AskCodi Desktop Launch ：AskCodi Desktop is officially released - CTO Agent planning, specialty agents are built in isolated git worktree, and the code does not leave the local machine. （2026-05-30）