Codelim
The AI Coding Agent You Control
Built for reliable software changes.
Codelim gives one Main Agent authoritative ownership of your task while specialists operate inside bounded,
verifiable subtasks.
"Your model. Your API key. Your machine. Your code. Your
license."
Run Codelim with the AI provider you choose—or use local models entirely on your machine. Codelim has no
mandatory cloud runtime and does not require your code to pass through a Codelim-hosted backend.
Activate once. Code offline forever.
No monthly seats. No Codelim token markup.
Engineered for Controlled, Verifiable Agentic Coding
AI coding agents can encounter tool-loop failures, capability drift, uncontrolled context growth, and unsafe mutations. Codelim is designed to constrain these failure modes through four architectural invariants.
Sovereign Main Agent
The Main Agent remains the authoritative coordinator of the user's objective. Specialists are bounded workers operating within runtime-enforced capability limits.
Typed Subtask Contracts
Delegation is explicit and bounded. Specialists receive typed contracts with defined context, turn, and
tool budgets, returning structured SubtaskResult envelopes with evidence lineage.
Non-Escalation Authority Sandbox
Workspace (.codelim/agents) and user (~/.codelim/agents) agent definitions can
extend workflows without exceeding the runtime's enforced capability ceiling.
Bounded Generation Safety
Oversized or invalid mutations are detected and constrained before they can compound into larger failures, with transactional recovery where supported.
Why Codelim?
An agent runtime for software engineering — engineered from first principles for predictable, verifiable outcomes.
| Traditional coding agents | Codelim |
|---|---|
| May allow unbounded or poorly constrained execution | Explicit execution budgets & stop conditions |
| Specialists can become uncontrolled | Typed subtasks with structured results |
| Custom agents may request excessive capabilities | Runtime-enforced authority ceiling |
| Large generation can corrupt files | Generation safety + transactional rollback |
| Tool behavior is difficult to inspect | Structured evidence lineage |
| Vendor / model dependent | Model agnostic (cloud BYOK & local) |
| One persona controls everything | Authoritative Main Agent + bounded specialists |
Built-in Specialists & Custom Agent Extensions
Built-in specialists provide core capabilities out of the box. User and workspace agents are extensions that operate inside strict capability ceilings.
Explorer (AgentExplorer)
Fast read-only codebase navigation, semantic symbol search, and architectural mapping.
Authorized Capabilities
- AST Grep & Semantic Symbol Search
- Structural Outline, Type Hierarchy, Call Hierarchy
- Fast recursive globbing and regex grep
Epistemic Truth Protocol
- [OBSERVED]: Verified directly in active source lines
- [INFERRED]: Deductions logically derived from code
- [UNKNOWN]: Unproven assumptions explicitly flagged
- Anti-wandering target checklist with early stop gating
Bring Your Own Agents (BYOA)
Extend Codelim without modifying its core runtime.
Define project-specific specialists in .codelim/agents/ or user-wide specialists in
~/.codelim/agents/.
The Main Agent can delegate appropriate subtasks to them, while the runtime enforces their authority
ceiling.
Contract-Enforced Delegation Cycle
↓
Subtask Contract → Custom Specialist Sandbox
↓
Structured Evidence → Main Agent
How Codelim Solves Complex Problems
Guesses are separated from observations, bounded by authority, and subjected to verification.
Objective Reception & Sovereign Main Loop
The user provides an objective. The Main Agent remains the authoritative coordinator, inspecting workspace context with runtime-permitted tools and planning execution.
Structured Subtask Contract Dispatch
When deep discovery or review is required, the Main Agent delegates a typed Subtask with
explicit context, constraints, and budget.
Multi-Source Agent Catalog & Authority Enforcement
The catalog resolves the candidate agent across Workspace (.codelim/agents), User
(~/.codelim/agents), and Built-in definitions, strictly clamping authority.
Evidence Envelope Return & Sovereign Continuation
The specialist returns a typed SubtaskResult with evidence and file diffs. The Main Agent
synthesizes findings, executes verified mutations, and finishes the task.
Transparency by Design
Codelim is built to make the coding-agent system observable and verifiable.
Beyond Black-Box Agents
Modern coding agents can feel like black boxes: you provide an instruction, the agent invokes tools, modifies files, and produces a result. When something goes wrong, it can be difficult to determine whether the problem came from the model, the tool contract, the validator, the executor, or the orchestration layer.
Codelim takes a different approach. Its tool contracts, validation rules, execution paths, traces, and verification mechanisms are designed to be inspectable and testable.
One Contract. One Execution Path. Evidence.
Codelim includes automated contract-audit tests that exercise the relationship across the entire execution pipeline:
This matters because a tool that is merely advertised to an agent isn't enough. The contract presented to the model must correspond to what the runtime can actually execute.
During development, Codelim encountered exactly this class of failure: tool capabilities advertised to the agent could drift from the capabilities actually available at runtime.
Instead of masking the problem, we built an automated contract-audit system to expose it.
The resulting verification process can exercise the real tools in a real Windows workspace — including file reading, writing, editing, directory enumeration, globbing, search, and shell execution — and record the resulting evidence.
The goal is not to claim that Codelim never fails.
The goal is to make failures observable, reproducible, diagnosable, and fixable.
That's an important distinction. Codelim is an engineering project where the agent itself is not the only thing being tested. The infrastructure that allows the agent to act is tested too.
- If the agent can act, we should be able to inspect how it acted.
- If a tool is available, we should be able to verify it.
- If a contract changes, we should be able to detect the drift.
- If something fails, we should be able to trace why.
Your Models. Your Machine. Bring Your Own Provider.
Codelim works with cloud and local models. Codelim does not require your code to pass through a Codelim-hosted backend. When you use a cloud model, you control which provider receives the context you explicitly send; when you use a local model, processing can remain entirely on your machine.
Pay Once. Run Your Autonomous Coding Runtime Forever.
No monthly subscription seats. No Codelim token markup. No mandatory cloud runtime. Connect Claude, GPT, Gemini with your own API keys at cost, or run 100% free with local models.
- Core Codelim CLI & Terminal Interface
- Bring Your Own Keys (BYOK — Claude, GPT, Gemini)
- Local Models via Ollama, LM Studio & vLLM
- Standard Agent Execution & Tool Pipeline
- Built-in Specialists & Custom Agents (
.codelim/agents) - Standard Verification & Test Execution
- Basic Codebase Intelligence & Symbol Search
- 1 Active Device Slot with Cryptographic Identity
- Bounded Agent Turns per task
- Personal License Updates Included
- Everything in Personal, plus:
- Autonomous YOLO Mode — unattended multi-turn execution
- Parallel Subagents — simultaneous bounded specialist execution
- Deep AST Codebase Indexing — semantic navigation across large codebases
- Unlimited Agent Turns — no artificial session turn cap
- Advanced verification & evidence inspection
- 2 Active Devices — desktop + laptop with cryptographic device identity
- Self-service cryptographic device migration
- Lost-device reset & recovery
- Hardware upgrade tolerance (≥ 70% soft similarity tolerance)
- Air-gapped activation support (
export-request) - BYOK with zero Codelim token markup
- All future Codelim Pro features and releases included at no additional software upgrade fee
- Lifetime technical developer support
- Everything in Pro, plus:
- Cryptographic Audit & Evidence Certificates
- Organization policy sandboxes & custom team rulesets
- Air-gapped enterprise tool bridges & private registries
- Self-hosted license authority deployment options
- Centralized team seat provisioning & recovery
- Dedicated architecture support & custom onboarding
- Commercial warranty & IP indemnification
One purchase. No recurring software subscription. You pay your chosen AI provider directly for cloud inference, or use compatible local models at no inference cost. Codelim does not add a token markup.
* Lifetime Pro Updates Definition: "Lifetime Pro Updates" means updates released for the Codelim Pro product during the commercial lifetime of the product, at no additional software upgrade fee. AI provider fees, API usage, third-party services, and future separately sold products or services are not included.
Submit an Activation Request
Use this form to send an activation request to the license endpoint after generating the signed request on your local machine.
Codelim Pro vs Cloud AI Coding Tools
A clear side-by-side view of developer economics, privacy guarantees, and software licensing.
| Dimension / Capability | Cloud AI Coding Tools (Subscription-based assistants) |
Codelim Pro (Founder's Launch) |
|---|---|---|
| Pricing | Recurring subscription ($20 – $200+/mo) | $79 one-time at launch ($99 regular) |
| Model Choice | Depends on provider | BYOK (Claude, GPT, Gemini) + Local Models (Ollama, LM Studio) |
| Token Billing | Provider-dependent usage caps & platform markups | No Codelim token markup |
| Runtime Licensing | Provider-dependent; frequent cloud check-ins | Runs offline after activation (no mandatory cloud connection) |
| Source Privacy & Telemetry | Code context transits vendor cloud infrastructure | No Codelim telemetry. Sent only to configured provider; local models run entirely on machine |
| Agent Execution | Provider-dependent session turn throttling | Autonomous multi-turn execution (unattended YOLO mode) |
| Specialist Architecture | Varies | Typed, bounded subtasks with atomic rollback safety |
| Machine Identity | Account-based login | Cryptographic device identity (2 active devices) |
| Air-Gapped Activation | Varies | Supported (export-request offline challenge) |
| Updates | Subscription-dependent | Pro updates included at no additional software upgrade fee |
| Licensing Model | Subscription access | Perpetual license. Use your purchased version forever. |
Install Codelim
One universal binary. Windows, macOS, and Linux.
Install Codelim first. Choose Personal or Pro when you're ready to activate your license.
No separate download for Personal or Pro. No account required to
download.
macOS / Linux
Universal installer for ARM64 & x86_64
curl -fsSL https://funpulsestudios.com/codelim/install.sh | bash
Universal single binary for macOS & Linux
Windows (PowerShell)
Native Windows x64 binary
iwr -useb https://funpulsestudios.com/codelim/install.ps1 | iex
Standalone executable with ANSI TUI
Run the one-line installer above for your OS. Standalone binary with zero external dependencies.
Launch Codelim in any repository. Runs in evaluation mode so you can inspect the interactive TUI.
Unlocks Personal ($20) or Pro ($79) capabilities with offline cryptographic machine binding.
Download freely → evaluate → purchase Personal or Pro → cryptographically activate → operate offline.
Everything You Need to Know
Fair questions. Straight answers. Everything about Codelim's architecture, security, and perpetual licensing.
Zero recurring software fees. Both Codelim Personal ($20) and Codelim Pro ($79 Founder's Launch / $99 regular) are perpetual software licenses. You download the universal binary freely, evaluate it on your machine, and activate your license. Once activated, the software runs offline without runtime license checks or mandatory Codelim cloud connections. There are no renewal traps, no seats to rent, and no recurring software bills.
All future Codelim Pro features and releases are included at no additional software upgrade fee. When you purchase Codelim Pro, your license includes Lifetime Pro Updates for the product edition during its commercial lifetime. As new autonomous agent capabilities, model integrations, AST improvements, and CLI features are released, they are available without upgrade fees, annual renewal taxes, or version paywalls. (Note: External AI provider API usage is billed directly by your chosen provider).
You also receive lifetime technical developer support directly from our core engineering team for workflow setup, BYOK provider configuration, and custom agent rules.
No Codelim telemetry. Your source code, file contents, and project context never transit Codelim servers. When you use cloud models (Anthropic Claude, OpenAI GPT, Google Gemini), prompts and context are transmitted only to the model provider you explicitly configure using your personal API keys. When you use local models (Ollama, LM Studio, vLLM), execution runs 100% locally on your workstation.
Codelim Personal includes 1 active device slot for an individual
developer. Codelim Pro permits 2 concurrently active devices (for
example, your primary desktop workstation and your laptop). In both editions, you can voluntarily
transfer slots between machines from the CLI (codelimcli license deactivate) or reset a
lost/destroyed machine through the customer portal.
Never. Codelim does not markup or sell AI tokens. You Bring Your Own Keys (BYOK) directly from Anthropic (Claude), OpenAI (GPT), or Google (Gemini) paying raw provider prices, or run 100% free offline local models with Ollama, LM Studio, or vLLM. You control your compute costs directly.
Codelim generates an Ed25519 device keypair stored in OS-protected storage (Windows DPAPI, macOS Keychain). Hardware fingerprinting uses a fuzzy similarity model with a generous ≥ 70% similarity tolerance, meaning component upgrades (new graphics card, RAM, SSD, BIOS update) will never deactivate your software.
Yes! Codelim includes built-in air-gapped activation support: run
codelimcli license export-request on the isolated machine to generate a cryptographically
signed activation challenge, approve it via any internet-connected machine on our web portal, and load
the signed entitlement file back onto the air-gapped workstation.
Codelim is an autonomous, sovereign agent runtime, not just an editor extension with a chat sidebar. It executes typed specialist subtasks with bounded authority contracts, performs deep AST codebase indexing, runs tests and builds, and verifies all modifications with atomic rollback capability.
Yes! Simply place markdown files in .codelim/agents/*.md (for project-specific specialists)
or ~/.codelim/agents/*.md (for personal specialists). Codelim automatically discovers them
and enforces strict security sandboxes.
Codelim is developed and published by FunPulse Studios as part of our developer tools and real-time AI technology portfolio.
The Autonomous Coding CLI You Own.
Activate once. Code offline forever.
No monthly seats. No Codelim token markup. No mandatory Codelim cloud runtime. Perpetual license with future
Pro updates included at no upgrade fee and direct developer support.