🤖AgenticCode

A true AI desktop coding assistant: here's how we revolutionized Kodiin!

We talk a lot about data sovereignty and local AI agents. But what really happens when an artificial intelligence doesn't just chat with you, but reads, writes, edits, compiles, tests and fixes code directly in your workspace, autonomously?

Today we take you behind the scenes of Kodiin's architecture, revealing how we combined the flexibility of language models with a genuine suite of native development tools:

🧠 Advanced Orchestration ("Council of Agents"): Thanks to the multi-provider architecture driven by AgentLlmDispatcher, Kodiin coordinates a network of specialized roles (Coordinator, Developer and Reviewer). Each agent is dynamically routed to the cloud or local model best suited to its specialization. If a provider fails, times out or hits its daily rate limit, an automatic chained fallback kicks in down to the offline local model, without ever blocking the workflow.

⚡ Smooth UI, Zero Freezes: To avoid blocking the user interface, all the heavy orchestration (file reading, context compression and inference) runs in the background via Task.Run. The application UI (.NET MAUI Blazor Hybrid) stays 100% responsive, while the Caveman and Caveman PrivacyGuard engine (also developed by us) proactively analyzes and compiles the context based on the provider's real token count.

📂 13 Real Tools & Git-Style Control: The agent doesn't "invent" — it interacts with the PC using 13 native tools (including bash, write, edit, grep/glob, git and build) and automatically activates language servers (LSP) for real-time diagnostics across more than 15 languages (C#, Python, Rust, Go, TypeScript and others). Furthermore, thanks to a line-by-line diff algorithm (LCS), every change is tracked live in a Git-style sidebar, allowing instant restore or undo of modified files.

🧩 Robust Parser & Auto-Consent: We optimized the tool-call parser, making it case-insensitive and capable of processing complex multiline content without risk of truncation. To smooth out development, the Code Developer agent now has auto-consent for writes to the workspace. This eliminates continuous on-screen confirmations, leaving the user total freedom to inspect or undo changes from the timeline and sidebar.

🔒 Total Privacy By Design: History, sessions and configurations never touch external servers — they live on your PC inside a unified, encrypted local database. No cloud is mandatory. On top of that, physical access to the application is protected by a mandatory unlock PIN and the internal PrivacyGuard encryption system for safeguarding sensitive data.

Kodiin isn't just another cloud-based AI wrapper: it's a desktop orchestrator designed to give developers total control over their working environment.

Your machine. Your agents. Your code. 💻✨

Further details:

🛠️ A real coding agent (not just chat)

1. Real agentic loop:the model decides when to use tools, executes, verifies and iterates until the problem is solved.
2. Complete tool set:file read/write/edit, code search (grep/glob), shell (bash), build, test, Python execution, git, GitHub (PR/issue), patch (apply_patch), project tree, folder list, undo/checkpoint (revert), backup, memory, todo/plan, web search and URL fetch, symbol navigation (LSP).
3. Self-verification:it compiles and runs tests on its own, self-correcting until everything's green.
4. Project recognition:detects stack, root namespace, target framework and existing code conventions before writing, so it fits in without "inventing" things.

🌐 Multi-provider with smart switching and fallback

1. Configurable provider catalog:(JSON, inspired by models.dev): multiple providers and multiple instances of the same type, with dedicated agent → provider mapping.
2. Chained fallback:if a provider fails (error, timeout, rate limit), the turn automatically passes to the next provider, down to the local model as a last resort.
3. Advanced rate limit handling:short, targeted retries, and once a daily cap (TPD) is hit, the exhausted provider is skipped for the rest of the session instead of retrying pointlessly.
4. Context/413 handling:proactive compaction based on the provider's real token count, with automatic reduction and retry when the request is too large.
5. Streaming robustness:an inactivity watchdog that avoids infinite blocking and retries or switches provider when a stream stalls.

🤖 Compatible with ALL models

1. Native function-calling:where supported, but also a universal parser for textual tool-calls (<function>...</function>,<tool_call>...,[TOOL_CALL]...): so Kodiin also works with "weaker" or local models that write calls as text instead of using the tools API.
2. No lock-in to a single vendor: you can mix cloud and local models.

👥 Collaboration between agents (lead · developer · reviewer)

1. Multiple roles cooperating: a coordinator, the agent that writes the code, and a reviewer on a different provider who reviews and requests fixes — block-by-block review to stay within token limits, with automatic choice of review provider.

🛰️ Code intelligence (multi-language LSP)

1. Automatic startup of language servers for diagnostics and symbol navigation on C#, Python, TypeScript/JavaScript, Go, Rust, C/C++, Ruby, Vue, Svelte, Astro, Zig, Swift, Elixir, F# and others (when the toolchain is present).
2. Immediate post-edit diagnostics on touched files, in addition to the full build.
3. Can be toggled on/off at will to save resources.

🔒 Security and privacy by design

1. All local:conversations, sessions, settings and history in a local database on your PC. No cloud required.
2. PIN lock:for the application, plus PrivacyGuard for sensitive data.
3. Granular tool permissions:each tool can be left "ask on request" (requires confirmation) or set to "always allow", with persistent rules and an "Allow all" switch. Destructive actions are protected by policy.

⏳ Reversibility and change safety

1. Automatic checkpoints:on every run, with revert to go back.
2. Backup:of files before overwrites, and undo from the sidebar.
3. External change detection:if a file changes outside of Kodiin, the agent is prompted to re-read it before overwriting (no lost work).

📊 Full observability (side docks)

1. Watchdog ⏱️:real-time timeouts and status of provider calls.
2. LSP 🛰️:language server flow (startup, diagnostics, errors).
3. LLM Errors 🚨:every error towards a model (HTTP code or "--" if local, description and copy button), with persistent file logging.
4. Token usage 📊:consumption per agent (local and remote) during the session, task-manager style, with chart and totals.
5. Run logs:detailed (JSONL) to analyze every agent step after the fact.

🐍 Built-in Python and Skills

1. Python environment managed by the app (runtime + package installation, even offline via wheel bundle): the agent can analyze CSVs, generate documents, scrape, etc.
2. Skills:callable specialized workflows (docx, pdf, sqlite, docker, git, nodejs, web-scraping, etc.) loaded on demand.

💻 User experience

1. "Sticky" sessions:a follow-up stays on the same agent/model, without re-classifying; switch only when you want.
2. Queued messages:you can keep typing while the agent works.
3. Interactive multi-choice questions:the agent can ask you how to proceed with selectable options.
4. Chat with Markdown rendering:(headings, lists, tables, code with copy).
5. Multi-language (localized UI), sounds and notifications, loading indicators.
6. MemoFlow:built-in notes, tasks and calendar; extensible connectors area.
7. Built-in code editor:with diff view and workspace files.

📋 Compatibility — In summary

Platform:MAUI/Blazor/Hybrid/C#. Architecture designed for extension to other platforms.

Providers / LLM APIs:OpenAI-compatible APIs (including, e.g., Groq), Azure OpenAI, Anthropic, Ollama, and OpenAI-compatible endpoints from Google, Meta, OpenRouter, Hugging Face. Local models via built-in runtime (LLamaSharp / GGUF) — works offline too. Endpoint, key and context window configurable per instance.

Languages / Managed stacks:C# / .NET, Python, TypeScript/JavaScript (and Vue/Svelte/Astro frameworks), Go, Rust, C/C++, Ruby, Swift, Zig, Elixir, F# and others — build/test/diagnostics when the toolchain is installed.

Recognized tool-call formats:Native function-calling,<function>...</function>,<function=name>...,<tool_call>{...},<function_call>{...}, and the text protocol[TOOL_CALL].

Gallery