Sigit MCP Server

siGit Code

siGit Code is a local-first AI coding agent. It runs on your machine by default, with optional cloud inference and remote automation when you choose them. No API key is required to start; the on-device path needs none at all.

It is the agent runtime for siGit Factory, the hosted version of the same product. Run it yourself, as below, or use siGit Code Cloud there if you would rather not host a model locally. sigit.si is Git hosting built for AI workflows.

It works in any codebase. In smbCloud repos it is more useful out of the box because it already understands the Rust workspace layout, deploy flows, auth boundaries, and GresIQ.

You can use it in two ways:

• ACP mode: Zed or another ACP-compatible editor starts it over stdio with the --acp argument
• Terminal mode: run sigit for the interactive chat UI

Every ACP client must pass --acp. It takes no other arguments, and it is what tells the binary to speak the Agent Client Protocol instead of opening the terminal UI.

Install

cargo install sigit

First run

The first launch downloads a GGUF model from Hugging Face. Expect roughly 1 to 2 GB, depending on the model. After that, loads come from disk and are much faster.

On macOS, siGit Code shares its model cache with the desktop app through an App Group container. If the desktop app already downloaded the model, the CLI reuses it.

Zed setup

Add this to ~/.config/zed/settings.json:

{
  "agent_servers": {
    "siGit Code": {
      "type": "custom",
      "command": "/absolute/path/to/sigit",
      "args": ["--acp"]
    }
  }
}

Use the full absolute path. ~ does not expand here.

Xcode custom agent

In Xcode, open Settings > Intelligence > Agents, add a custom agent, and set:

• Executable: the absolute path to sigit
• Arguments: --acp

In Xcode the --acp mode also loads the selected on-device model on the first prompt, so you do not need to send /load from the Xcode chat.

To let siGit use Xcode's build, test, and project tools, enable Allow external agents to use Xcode tools in Xcode's Intelligence settings, keep the project open, and add this to ~/.config/sigit/mcp.toml:

[[server]]
name = "xcode"
command = "xcrun"
args = ["mcpbridge"]

VS Code

With siGit Code Extension

Install from the Visual Studio Code Marketplace.

{
  "sigit.agents": {
    "sigit": {
      "name": "siGit (on-device)",
      "command": "sigit",
      "args": ["--acp"],
      "env": {}
    },
  },
  "sigit.agent.default": "sigit"
}

With ACP Client

Install ACP Client, then add:

{
  "acp.agents": {
    "siGit Code": {
      "command": "sigit",
      "args": ["--acp"],
      "env": {}
    }
  }
}

ACP support

siGit Code speaks Agent Client Protocol v1 over stdio. As of 1.7.0 it implements the whole stable v1 surface an agent can offer:

session/fork is still marked unstable in the protocol. Draft v2 is not enabled.

Terminal mode

Run sigit in a terminal and you get the same model and system prompt as the editor integration, just in a full-screen chat UI.

Terminal mode currently needs Unix terminal behavior, so it works on macOS and Linux only.

Headless and CI mode

Use sigit run to execute the same agent from scripts, CI, or another siGit Factory client:

sigit run "Review this repository and run the focused tests" --cwd .

Every run receives a durable session ID. The ID is printed to stderr in text mode and included in every event in JSONL mode. Resume the same conversation from a later command—or import it in an ACP client—by passing that ID:

sigit run "Continue with the next issue" --resume <session-id>

For automation, JSONL output provides session, assistant-delta, tool-call, tool-result, result, and error events on stdout. Logs remain on stderr.

sigit run "Run the checks" --output jsonl --allow-tool run_command

Mutating tools still follow siGit's permission policy. Because a headless run cannot answer an interactive permission prompt, approve only the tools the run needs with repeatable --allow-tool flags. The legacy sigit -p "<prompt>" form remains supported. See the headless execution reference for the event contract and exit codes.

Telemetry

siGit Code itself collects no usage analytics. On-device models run on Onde Inference, and Onde can report model timing to its own dashboard. That reporting only switches on in builds where Onde's credentials were embedded at compile time. When it is on, siGit Code sends:

• one event when an on-device model finishes loading: the model's Hugging Face repo ID, its display name, and how long the load took;
• one event per on-device response: the model ID, a per-process request ID, the response time, the time to first token when it was measured, and whether it succeeded, errored, or was cancelled.

Nothing from your conversation goes with them: no prompts, responses, file paths, or code. siGit Code doesn't set a machine identifier, so every install reports as the same onde-unknown edge, and it sends no location. Models you run through siGit Code Cloud or your own endpoint send no Onde events.

To see whether your build reports, load an on-device model and check the log for ChatEngine: pulse telemetry enabled or ChatEngine: pulse telemetry disabled. siGit Code logs to stderr, which an editor shows in its agent log. Terminal mode writes it to $TMPDIR/sigit.log.

To turn it off, set ONDE_DISABLE_PULSE=1 in the environment siGit Code runs in. For an editor, put it in the agent's env block:

"env": { "ONDE_DISABLE_PULSE": "1" }

Platform support

License

Apache 2.0

Copyright

© 2026 siGit Code & Deploy. See NOTICE for the rights holder and distributor.