Introduction
In contemporary software development, building autonomous coding agents and executing end-to-end engineering tasks on lightweight agent runtimes like DeepSeek Harness (dsh) has become standard practice. However, when developers attempt to maintain high-velocity development feedback loops, access constraints surrounding foundation models frequently impede momentum. Obtaining commercial API keys from tier-one providers entails complex registration procedures, international payment bindings, and enterprise identity checks, while high-volume context windows exhaust costly token balances rapidly. For individual engineers, students, and research teams looking to validate algorithmic logic, debug agent extensions, or test frontier architectures, orchestrating proprietary multi-account reverse proxies introduces unsustainable DevOps overhead. Abrupt quota window exhaustion, transient network timeouts, and token exhaustion repeatedly break development flow.
Initiated and maintained by open-source organization Ebony-Vinyl, dsh-our-free-model emerged as a purpose-built, free model provider infrastructure plugin for the DeepSeek Harness ecosystem. Accumulating over 4,500 GitHub stars and ascending to the top of both Trendshift and GitTrend trending repositories, dsh-our-free-model adheres to a pure plugin design philosophy. Requiring no account registration, no login session, and zero API keys, it grants immediate access to frontier large language models, including DeepSeek V4.1 Flash and Kimi K3, directly inside the dsh environment. The plugin operates non-invasively without modifying the dsh core kernel, requires zero compilation build steps, and introduces no third-party runtime dependencies. With transparent upstream connections, dynamic network egress probing, and physical token reasoning budgets, it establishes a reliable, keyless inference runtime for agentic workflows.
Key Features
Headless Decoupled Mounting with Zero-Dependency Runtime Compatibility
Conforming to the architectural principle of DeepSeek Harness where everything is treated as a modular plugin, dsh-our-free-model establishes strict separation of concerns. The plugin treats the core llm interface as its sole mandatory dependency, completely decoupling model invocation from desktop graphical shells or browser environments. Consequently, inside headless server nodes, CI/CD containers, and terminal runtimes like dsh-tui, the plugin initializes instantly and dispatches model capabilities to the host without UI dependencies. For environments equipped with web interfaces, the dashboard and configuration modules reside on an independent fiber scheduler. The subsystem awaits host webServer availability before registering administrative endpoints asynchronously, avoiding initialization deadlocks and preventing settings views from failing to mount due to out-of-order startup sequences.
Live Egress Probing and Fault-Tolerant Availability Isolation
Public model gateways are prone to upstream routing shifts and international networking inconsistencies. Traditional model switches rely on static model catalogs, often resulting in abrupt streaming disconnects mid-session. dsh-our-free-model discards static rosters, executing active health probes from the host machine's actual physical network egress upon every catalog refresh. The engine disambiguates failure semantics deterministically: when an upstream gateway returns HTTP 404 or declares that a model is unavailable, that model is pruned from the model picker; transient conditions such as 5xx server strain, 429 quota windows, or network socket timeouts are treated as temporary connectivity jitter, preserving model reachability. Models restricted by geographic routing policies are isolated into a dedicated region-limited group, clarifying regional accessibility boundaries while guaranteeing the model dropdown never suffers fatal empty states.
Physical Token Budgeting for Deterministic Reasoning Control
Conventional reasoning effort controls pass speculative reasoning_effort string parameters upstream, which heterogeneous public gateways frequently ignore or misinterpret. dsh-our-free-model establishes client-side control by mapping reasoning tiers—Light, Balanced, and Deep—into strict physical output token budgets of 2,048, 8,192, and the model hardware ceiling respectively. For architectures where chain-of-thought processing cannot be disabled, the framework doubles budget tiers to 4,096 and 16,384 tokens, resolving resource contention where internal reasoning competes against final generated responses within a single output limit. These active limits are recorded per invocation and surfaced transparently on model cards, ensuring that user-selected reasoning depths enforce substantive thinking before token generation begins.
Local-First Persistence and Zero-Telemetry Privacy Boundaries
To safeguard developer source code and system prompts, dsh-our-free-model enforces strict local-first data boundaries. Operational metrics, configuration parameters, 17-week token heatmaps, time-to-first-token (TTFT) benchmarks, and token generation velocity samples persist exclusively as plain JSON documents within the local host configuration directory at DSH_HOME/our-free-model/. The plugin contacts no centralized telemetry services and transmits no analytical data to external hosts. At the HTTP interface layer, where plugin routes hold priority over the host kernel, the system mirrors kernel-level trust fences: every inbound request undergoes strict connection authorization checks, falling back to structural origin-matching and cross-site request forgery (CSRF) defenses in untrusted contexts to block unauthorized access from malicious scripts.
Loop-Protected Local OpenAI Gateway and LAN Relay Forwarding
To extend keyless model capabilities to external developer tools such as Cursor, VS Code extensions, or local translation utilities, dsh-our-free-model includes an integrated OpenAI-compatible forwarding gateway. By default, the service binds strictly to the loopback interface (127.0.0.1), generating cryptographically secure API keys verified using constant-time comparisons (timingSafeEqual) to prevent timing side-channel exploits. When developers share model inference across a local area network, they can enable the dedicated LAN relay module. The relay binds routable network adapters, issuing isolated relay credentials that the host replaces internally before forwarding requests to the core gateway. Restricted strictly to whitelisted /v1/* endpoints and guarded by hop-limit counters to prevent self-referential forwarding loops, the relay reconciles network security with multi-device productivity.
Quick Start
Installing via Command Line and Configuring Proxies
On workstations with the DeepSeek Harness CLI configured, install the plugin using native harness package commands. In network environments operating behind proxies, export terminal proxies prior to fetching remote catalogs:
# macOS and Linux (zsh / bash)
export HTTP_PROXY="http://127.0.0.1:7890"
export HTTPS_PROXY="http://127.0.0.1:7890"
# Add the plugin to your active runtime profile (for example, web profile)
dsh plugin --profile web add /path/to/dsh-our-free-model
# Restart the dsh host daemon to complete plugin mounting
dsh restart
# Windows environments (PowerShell)
$env:HTTP_PROXY = "http://127.0.0.1:7890"
$env:HTTPS_PROXY = "http://127.0.0.1:7890"
# Execute plugin mounting command via PowerShell
dsh plugin --profile web add C:\Users\Username\dsh-our-free-model
Upon restart, host logs will output our-free-model: mounted, confirming that frontier models are accessible within your dsh session.
Desktop App and AIO Deployment Prerequisites
When installing into the DeepSeek Harness desktop application or the DSHEAC AIO bundle, developers must adhere to host profile validation gates. To maintain offline determinism, desktop hosts inspect profile trees prior to booting web services, aborting execution if unofficial symlinks or directory junctions are detected:
# Avoid npm link or soft junctions; copy the plugin as a physical directory
# Target path: ~/.dsh/profiles/<your-profile>/plugins/dsh-our-free-model
mkdir -p ~/.dsh/profiles/default/plugins/dsh-our-free-model
cp -r /path/to/dsh-our-free-model/* ~/.dsh/profiles/default/plugins/dsh-our-free-model/
Once the physical directory is copied, restart the desktop client. The plugin management interface will register the Our Free Model module automatically.
Enabling the Local Gateway for Third-Party Client Integration
Navigate to Settings → Our Free Model → Local Forwarding, toggle the service on, and copy the auto-generated API key. Verify connection endpoints using standard command-line tools:
# Query the OpenAI-compatible model catalog endpoint (default port 8326)
curl -s http://127.0.0.1:8326/v1/models \
-H "Authorization: Bearer your-generated-local-key"
# Dispatch a streaming chat completion request
curl -X POST http://127.0.0.1:8326/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer your-generated-local-key" \
-d '{
"model": "deepseek-v4.1-flash",
"messages": [{"role": "user", "content": "Write a quicksort implementation in TypeScript"}],
"stream": true
}'
In third-party developer tools like Cursor, Claude Dev, or NextChat, set the Base URL to http://127.0.0.1:8326/v1 and supply the generated access key to utilize free frontier inference directly.
Frequently Asked Questions
Troubleshooting Desktop App Aborts with the PROFILE_UPGRADE_REQUIRED Error
This abort occurs when the DeepSeek Harness desktop client identifies symbolic links or junction references within its profile directory during pre-flight checks. To guarantee offline stability and prevent broken references, desktop application integrity gates reject non-kernel symlinks. To resolve this condition, close the desktop application completely, navigate to the user profile directory at ~/.dsh/profiles/, and delete the symlinked folder created during manual linking. Replace the link by copying the plugin codebase as a standalone physical directory. Once physical files occupy the profile plugins directory, launch the desktop client again and the security exception will resolve.
Understanding Grayed-Out Models and the Region-Limited Grouping
When models appear grayed out or move into the region-limited dropdown section, it indicates that live health checks from your host network egress were blocked by upstream geographic access controls. Upstream providers like OpenCode Zen and Kilo AI enforce firewall filtering based on client IP origins. In this state, the underlying connection logic functions correctly, but the current egress IP address is not permitted by upstream policies. The standard remediation involves configuring your terminal or proxy routing rules to route requests through a globally accessible exit node. After switching network routes, click the manual re-probe button in the settings panel or await the scheduled background check; the system will re-evaluate egress capabilities and restore affected models to the primary selection list.
Diagnosing HTTP 400 and 401 Rejections on the Local Forwarding Gateway
Authentication rejections on forwarding endpoints typically stem from misaligned credential scopes between loopback and local area network requests. When connecting locally on 127.0.0.1, confirm that request headers contain a valid Authorization: Bearer <key> header matching the active local key displayed in the settings panel. If making requests from an external machine across a local area network, the default loopback listener rejects inbound traffic by design. To enable multi-device access, navigate to settings, enable the LAN Access toggle, and authenticate using the specifically generated LAN Relay Key rather than the loopback key, ensuring traffic routes strictly to supported /v1/* completion endpoints.
Assessing Privacy Boundaries and Model Logging Policies on Free Channels
The free tier in dsh-our-free-model relies on open capacity supplied by third-party gateways. Certain providers, notably the Kilo AI public pool, explicitly declare in model specifications that user prompts may be retained by upstream servers to refine future model iterations. Developers must maintain clear operational boundaries: while the plugin is exceptionally well-suited for general algorithmic problem-solving, open-source prototyping, public documentation research, and code refactoring, never submit production database credentials, proprietary corporate business logic, personally identifiable information (PII), or private keys to public free lanes. For mission-critical corporate workloads, developers should direct traffic to private model deployments or dedicated commercial API keys.
