01 // RUNTIME
Portable agent core
One architectural core designed to power IDE, CLI, desktop, web, mobile and CI surfaces without redefining execution semantics for every client.
Inspect spec ↓
■ PLATFORM THESIS // ARCHITECTURAL FOUNDATION
Build agents like production systems
CodingAgent.in treats an AI coding agent as a controlled engineering runtime: context, model policy, tools, workspaces, memory, permissions, evidence and independent verification are explicit components.
02 // FABRIC
Model fabric routing
Route by coding capability, privacy, context, latency and operator policy instead of binding engineering workflows to a single model vendor.
Inspect spec ↓
03 // BOUNDARY
Tool governance
Filesystem, shell, Git, browser, database and MCP actions belong behind explicit permission, sandbox, approval and audit boundaries.
Inspect spec ↓
04 // SOVEREIGNTY
Local-first execution
Local models and local context are first-class design targets for private repositories, offline work and environments where external inference is not appropriate.
Inspect spec ↓
05 // INTEGRITY
Evidence-led verification
Builds, tests, security checks and artifact hashes should determine completion. A model saying "done" is not a verification result.
Inspect spec ↓
06 // CAPABILITY
Reusable versioned skills
Turn successful, reviewed workflows into versioned skills with declared tools, inputs, policy requirements and verification criteria.
Inspect spec ↓
One core, every surface
The same governed runtime is reachable from the editor, the terminal, CI, the browser, and mobile — each surface exposes the same policy and verification semantics.
VS Code
IDE
Repository-native agent workflows, diff gutter views, inline code proposals, interactive approval buttons, and verification gates.
Inline Diff Reviews
Gutter Action Gates
Local Model Status Bar
Terminal Sync
VS Code Extension API + Language Server Protocol
JetBrains
IDE
Agentic engineering inside established JVM, Python, and polyglot workflows across IntelliJ, PyCharm, and WebStorm.
Refactoring Inspections
Gradle/Maven Verification
Project Structure Graph
JetBrains Plugin SDK
Developer CLI
TERMINAL
Scriptable autonomous missions, local model control, CI integration, UNIX piped diffs, and headlessly verifiable tasks.
Headless Execution
Stdout Diff Streams
Cron Automation
GGUF Runner
Native binary via Rust/Node with zero dependencies
Desktop App
DESKTOP
Cross-project missions, visual local model manager, persistent workspace state, and hardware VRAM monitors.
Multi-Project Cockpit
Local Model Downloader
Hardware Dashboard
Offline Mode
Tauri / Webview native shell
Web Cockpit
WEB
Remote mission control, project visibility, team audit logs, organization policy distribution, and shared memory.
Team Collaboration
Organization Policy Manager
Audit Log Explorer
Shared Skills
Browser Single Page Application (app.codingagent.in)
Mobile Gateway
MOBILE
Monitor long-running missions, review staged diffs on the go, and approve consequential deployments with one tap.
Push Notifications
One-Tap HITL Approvals
Mission Health Checks
PWA & Native Mobile Clients
CI/CD Pipelines
CI / CD
Automated PR triage, security patch generation, typecheck verification, and test coverage gating in pull request workflows.
GitHub Actions Runner
GitLab CI Integration
Automated PR Reviews
SLSA Attestations
Containerized Runner Action
MCP Fabric
PROTOCOL
Consume and expose governed tools, compiler analyzers, and external APIs through Model Context Protocol standard.
Bidirectional Tool Discovery
Policy Interception
JSON-RPC Stdio/SSE
Taint Tracking
Anthropic Model Context Protocol Standard
Mission traces
ILLUSTRATIVE DEMO TRANSCRIPTS — not live execution. Real missions, approvals and evidence come only from a configured backend.
terminal · illustrative trace
[❯]codingagent run "harden the API and verify the fix"
[plan]decompose repository task → 5 work units across src/auth & src/api
[route]choose model by capability, privacy [Local Ollama Qwen2.5-Coder 32B]
[tool]filesystem.read(src/auth/jwt.ts) →ALLOW
[tool]filesystem.write(src/auth/jwt.ts) → diff staged in sandbox workspaceALLOW
[policy]evaluate action: shell.run("npm test") → within isolated containerALLOW
[verify]build / typecheck / unit tests (14 passed, 0 failed, 0 warnings)
[result]completion accepted via test evidence: SHA-256 [e3b0c44298fc1c149...]
The execution control loop
Every mission passes six governed stages — with explicit governance actions, produced artifacts, and a safety check at each boundary.
01
Understand
Read goal, repository context, and policy rules
The agent establishes an isolated context envelope: reading repository configurations, git status, active branch, and applicable security policy constraints before forming any intent.
Governance: Enforce read-only workspace bounds and scrub potential secret leaks from contextual prompts.
Safety check: Verify that target files are within permitted repository boundaries.
Task Context Snapshot
Active Policy Manifest
Symbol Dependency Map
02
Plan
Produce a validated, non-cyclic task graph
The intent is systematically decomposed into discrete work units with explicit preconditions, file touched boundaries, and verifiable acceptance criteria.
Governance: Compile DAG into JSON Schema; detect and reject cyclic references or unverified assumptions.
Safety check: Ensure plan requires human operator approval for any consequential or external side effects.
Task Graph (DAG)
Acceptance Criteria Spec
Expected Diffs Budget
03
Route
Select model by capability, privacy, and latency
The model fabric evaluates the task profile against hardware capability and privacy policy: private or air-gapped repositories route strictly to local models (Ollama, vLLM, GGUF).
Governance: Check repository classification against allowed model endpoint registries.
Safety check: Block dispatch if task privacy classification forbids external cloud egress.
Model Routing Token
VRAM Allocation Certificate
Inference Config
04
Execute
Use tools inside scoped, sandboxed workspaces
The model invokes declared tools through the governed MCP or native layer. Each tool call is filtered through policy authorization before execution in an isolated sandbox.
Governance: Execute in lightweight sandbox (bubblewrap/container); monitor file write bounds.
Safety check: Taint tracking prevents untrusted tool outputs from escaping sandbox boundaries.
Unified Diffs
Tool Execution Logs
Sandbox Traces
05
Verify
Run independent acceptance gates and compilers
Completion is determined exclusively by external non-LLM tools: compilers, type-checkers, unit test runners, and security linters. A model declaring "done" is disregarded without evidence.
Governance: Execute hermetic build command; capture compiler exit code and stdout/stderr evidence.
Safety check: Assert exit code == 0 and cryptographic artifact hash matches expected digest.
Build Attestation
Test Pass Evidence
Differential Coverage Report
06
Learn
Promote reviewed knowledge and versioned skills
Successful, operator-approved missions can be distilled into versioned SKILL.md modules. Lessons learned, failure patterns, and architectural insights are preserved in durable memory.
Governance: Store sanitized mission telemetry and versioned skill manifests in the repository memory store.
Safety check: Scrub all temporary runtime credentials and personal data prior to knowledge promotion.
Versioned Skill Manifest
Audit Provenance Log
Memory Store Delta