Instagit vs DeepSeek-Reasonix: Understanding the SaaS Wrapper and the Open-Source Engine

Instagit is a hosted web service that consumes the open-source DeepSeek-Reasonix engine through OpenRouter API headers, while DeepSeek-Reasonix is the standalone autonomous coding agent you can run locally, embed via Go SDK, or integrate into custom workflows.

The esengine/DeepSeek-Reasonix repository contains the complete source code for an autonomous coding engine written in Go. If you encounter references to Instagit inside configuration files or documentation, understanding the difference between Instagit vs DeepSeek-Reasonix is essential: Instagit operates as a commercial front-end that leverages this engine, whereas the repository itself provides the core execution logic, model routing, and plugin architecture that powers the underlying functionality.

What Is DeepSeek-Reasonix?

DeepSeek-Reasonix is the open-source engine that provides autonomous coding capabilities. Distributed as a single static binary (reasonix), it offers multiple native interfaces including a CLI/TUI, a desktop application, and a VS Code extension. The engine handles context management, multi-step reasoning, tool execution, and communication with Large Language Models (LLMs) through configurable providers.

Key components reside in the following locations:

• Core logic and setup: [README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/README.md)
• Command-line interface: [docs/CLI.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/CLI.md)
• Editor protocol: [docs/ACP.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/ACP.md) (describes how editors communicate with the engine)
• Go SDK: [sdk/go/README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/sdk/go/README.md) for embedding in applications
• Desktop client: [desktop/README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/desktop/README.md)

What Is Instagit?

Instagit is a commercial, hosted SaaS product that presents itself as an AI coding assistant. Rather than maintaining its own inference infrastructure, Instagit connects to the DeepSeek-Reasonix engine via the OpenRouter API. According to the source configuration in opencode.json, Instagit identifies itself through specific HTTP headers when making requests.

In [opencode.json](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/opencode.json), the OpenRouter provider configuration explicitly declares:

{
  "provider": {
    "openrouter": {
      "options": {
        "headers": {
          "OpenRouter-App-Title": "Instagit",
          "OpenRouter-App-URL": "https://instagit.com"
        }
      }
    }
  }
}

These headers allow the Reasonix engine (or OpenRouter's routing layer) to identify requests originating from the Instagit platform.

Key Architectural Differences

Feature	Instagit	DeepSeek-Reasonix
Deployment Model	Hosted SaaS; requires only a web browser.	Self-hosted binary; runs locally or on private infrastructure.
Configuration Control	Fixed model selection and feature set controlled by Instagit operators.	Full control via reasonix.toml to select providers, models, and plugins.
Code Access	Closed-source front-end; not part of this repository.	Fully open-source under the repository root, including engine, SDK, and documentation.
Integration Method	HTTP API calls to OpenRouter with identifying headers.	Native process execution, Go library import, or local socket communication.
Extensibility	Limited to Instagit's UI features.	Plugin SDK available; customizable sandboxes and tool integrations.

How Instagit Connects to the Engine

When you use Instagit, your prompts are forwarded to the Reasonix engine through the OpenRouter API infrastructure. The connection is defined by the header configuration found in opencode.json, which marks the request with:

• OpenRouter-App-Title: Instagit
• OpenRouter-App-URL: https://instagit.com

This metadata allows the routing layer to attribute usage and apply provider-specific optimizations (such as fallback ordering to fireworks or cerebras for the openai/gpt-oss-120b model) while the actual reasoning and code generation logic executes within the DeepSeek-Reasonix architecture.

Practical Usage Examples

Running DeepSeek-Reasonix Locally

To use the engine directly without Instagit, install the binary and run interactive sessions:

# Install via npm or Homebrew

npm install -g reasonix

# or

brew install esengine/reasonix/reasonix

# Configure provider credentials

reasonix setup

# Start interactive TUI mode

reasonix

For detailed command reference, see [docs/CLI.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/CLI.md).

Accessing the Engine Through Instagit (OpenRouter API)

To emulate how Instagit invokes the engine, send requests to OpenRouter with the identifying headers defined in opencode.json:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "OpenRouter-App-Title: Instagit" \
  -H "OpenRouter-App-URL: https://instagit.com" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-120b",
    "messages": [
      {"role": "system", "content": "You are an expert Go programmer."},
      {"role": "user", "content": "Implement a concurrent worker pool pattern"}
    ],
    "provider": {
      "order": ["fireworks", "cerebras"],
      "allow_fallbacks": true
    }
  }'

This matches the provider configuration and header injection specified in the repository's opencode.json.

Embedding the Engine in Go Applications

Unlike Instagit, which operates as a separate web service, you can embed DeepSeek-Reasonix directly into your Go programs:

package main

import (
    "fmt"
    "log"
    
    reasonix "github.com/esengine/DeepSeek-Reasonix/sdk/go"
)

func main() {
    // Initialize client with configuration path
    client, err := reasonix.NewClient("./reasonix.toml")
    if err != nil {
        log.Fatal(err)
    }
    
    // Execute autonomous coding task
    response, err := client.Run("Refactor this code to use channels instead of mutexes")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println(response.Code)
}

Refer to [sdk/go/README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/sdk/go/README.md) for complete SDK documentation.

Source File Reference

The following files define the relationship between the engine and external consumers like Instagit:

• [opencode.json](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/opencode.json) — Contains OpenRouter configuration and Instagit identification headers
• [README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/README.md) — Overview of engine capabilities and installation methods
• [docs/ACP.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/ACP.md) — Agent Communication Protocol for editor integrations
• [docs/CLI.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/CLI.md) — Complete CLI reference and usage examples
• [sdk/go/README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/sdk/go/README.md) — Go SDK integration guide
• [desktop/README.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/desktop/README.md) — Desktop application build instructions

Summary

• Instagit is a commercial web interface that routes user requests to the DeepSeek-Reasonix engine via OpenRouter API calls, identifying itself through specific HTTP headers in opencode.json.
• DeepSeek-Reasonix is the open-source autonomous coding engine (Go-based) that provides the underlying reasoning, tool execution, and model management capabilities.
• You can run the engine locally using the reasonix CLI, embed it via the Go SDK, or consume it through hosted intermediaries like Instagit.
• The repository's configuration files explicitly define how external SaaS products identify themselves when proxying requests to the engine.

Frequently Asked Questions

Can I use DeepSeek-Reasonix without Instagit?

Yes. DeepSeek-Reasonix is designed to run as a standalone binary. You can install it locally via npm or Homebrew, configure your own API keys in reasonix.toml, and use the CLI or desktop interface without any connection to Instagit or OpenRouter, or connect directly to providers like OpenAI, Anthropic, or local Ollama instances.

Is Instagit open source?

No. Instagit is a separate commercial product that uses DeepSeek-Reasonix as its underlying engine. The Instagit source code is not included in the esengine/DeepSeek-Reasonix repository. The repository only contains the open-source engine and its configuration for recognizing Instagit as a client via the OpenRouter-App-Title header.

What models does Instagit use when calling DeepSeek-Reasonix?

According to opencode.json, the default configuration routes to openai/gpt-oss-120b for heavy reasoning tasks (with fallback providers ordered as fireworks then cerebras) and qwen/qwen3-32b for lighter operations (with fallbacks to sambanova and groq). However, Instagit operators control the final model selection and may override these defaults in their production deployment.

How do I build my own Instagit-like interface?

To build a client similar to Instagit, deploy the DeepSeek-Reasonix engine on your infrastructure and configure the OpenRouter provider headers in your opencode.json to include your application's identifier. Use the ACP protocol documented in [docs/ACP.md](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/ACP.md) to communicate between your web front-end and the engine, or import the Go SDK to embed the engine directly into your backend service.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}