Where Your Code Goes, and Where It Doesn't.
Nebula Swarm is a set of plain-text files and small scripts that we install into your repository. It runs inside the AI coding tool you already use, on your model-provider account, against your Git host, Jira and Confluence. Your code never comes to Sidera Labs. A human on your team merges every pull request.
- No path to us No Nebula Swarm script uploads your source code to Sidera Labs. There is no Sidera Labs server in the loop.
- Your accounts Model calls, Git pushes and Jira updates use credentials you issue and can revoke.
- Humans merge Agents open pull requests. A person on your team decides what reaches main.
Every Connection Nebula Swarm Can Make.
Solid lines are the working flows: they run on your machine and land in your accounts. Dashed lines are optional and stay off until someone sets them up. The red line is the one people ask about. It doesn't exist.
Scroll sideways to see the whole diagram.
Your Model Choice Decides Where Model Traffic Goes.
Nebula Swarm hands each task to your AI coding tool and passes it no model, endpoint or API key. The tool's own settings decide where prompts, file contents and command output go.
Claude Code, Codex, Gemini CLI or Copilot.
By default, each tool sends its model traffic to its own provider (Anthropic, OpenAI, Google or GitHub), under your account and your agreement with that provider.
DeepSeek.
Point one of those tools at DeepSeek, and model traffic goes to DeepSeek's API, under your DeepSeek account and its terms. You set that up in the tool, not in Nebula Swarm.
A local LLM.
Point a tool at a model you host, and model traffic stays on your machine or your own network. The tool's own product telemetry is still set in the tool.
Whichever you choose, Nebula Swarm's own scripts call no model API, and every other row in the table below stays the same.
What Leaves the Machine, Where It Goes, and How to Turn It Off.
This list comes from reading the harness scripts line by line. Each row names the file that makes the call, so your team can check it.
| Flow | What is sent | Destination | Default | How to disable |
|---|---|---|---|---|
| Model calls | Prompts, plus whatever files and command output the AI tool reads during a task. This is how any AI coding tool works; Nebula Swarm adds no extra channel. | Your model provider, through your AI coding tool, on your account and data terms. | On | Controlled in your AI tool and provider account. You choose the provider and its retention settings. |
| Git host | Commits on task branches and pull requests (git push, gh pr create). |
Your Git host, as the engineer or bot account you authorize. | On | Core to the work. Limit it with branch protection and a scoped token (see Controls). |
| Jira | Reads tickets by JQL. Creates tickets, edits descriptions (adds a run-ID marker), moves status, adds comments and issue links. task_tracker_jira.py via the jira CLI | Your Jira, with your API token. | Opt-in at install | JIRA_ENABLED=false. Nebula Swarm then tracks tasks in a local file in the repo. |
| Confluence | Read-only. Search, read pages, list child pages. The script only sends GET requests. confluence.py | Your Confluence, with your token. | Off until configured | Leave CONFLUENCE_URL and CONFLUENCE_API_TOKEN unset. |
| Knowledge graph | Upsert: the raw text of docs and config files (Markdown, JSON, TOML and similar) and AI-written summaries of source files, including function signatures. Gitignored files are skipped. Query: the question text. oracle_upsert.py, oracle_query.py | A LightRAG server at ORACLE_URL. The script's fallback is a server on the same machine. [confirm] who hosts it for clients |
Off | Leave ORACLE_URL unset. Every step skips silently. |
| Update check Decide on this | A request for the latest commit of the Nebula Swarm upstream (gh api, falling back to git ls-remote). Nothing from your repo is sent. GitHub sees the engineer's GitHub identity and IP. Upgrading runs only after an explicit yes. minions_update.py |
GitHub, Nebula Swarm upstream repository. [confirm] final upstream repo | On | Runs at the start of each interactive planning step; snoozed 24 hours after a "no"; skipped in unattended runs. The code has no off switch yet. [confirm] add one Until then, block the upstream at the network. |
| Telemetry Decide on this | Event name (install, upgrade, task complete), timestamp, OS, CPU type, shell, Nebula Swarm version, repo folder name, Git remote URL, current branch, whether Jira is on, and task ID, run ID, PR number and agent type. No titles, code, commit messages or names. minions_telemetry.py, install.sh | A collector URL, if one is set in MINIONS_TELEMETRY_URL or written by the installer. The shipped default is empty. |
Off (no URL) | MINIONS_TELEMETRY=0, or leave the URL unset. [confirm] we ship with no collector URL |
| Feedback | Only text a person writes and chooses to send with /minions-feedback, plus repo folder name, Git remote URL, branch and timestamp. minions_feedback.py |
A collector URL in MINIONS_FEEDBACK_URL. |
Off (no URL) | Leave MINIONS_FEEDBACK_URL unset. |
| Install and upgrade | Downloads the Nebula Swarm source from GitHub. Optionally installs the gh and jira command-line tools from their official sources. install.sh |
GitHub and the tools' official release pages. | Install time only | CLI installs are opt-in. You can install from a reviewed local copy instead. |
| Dependencies | Package installs when a task worktree is created (for example npm ci, pip). worktree.sh |
Whatever package registry your project already uses. | On | Point your package manager at your internal mirror. Nebula Swarm uses your project's settings. |
Not in this table: your AI coding tool's own product telemetry. That belongs to the tool vendor and is controlled in the tool's settings, not by Nebula Swarm. Rows marked "Decide on this" are the ones we'd like your team to decide on.
Two Things We're Telling You Up Front.
The update check is on by default. It sends nothing from your repository, but it does contact GitHub from the engineer's machine. If your policy blocks that, we'll turn it off at install. [confirm]
Telemetry and feedback send the Git remote URL as written. If a remote URL contains an embedded token (for example https://user:token@host/…), the current code would send that too. The flows are off by default, but don't use credentialed remote URLs, and we'll strip credentials before any collector is ever enabled. [confirm] fix scheduled
What Stops an Agent From Shipping Something on Its Own.
Some of these controls are in Nebula Swarm's code. The rest are your existing settings, which we help you configure. We show which is which.
A human merges every pull request.
A task ends with an open pull request and stops. A person on your team reviews and merges it.
In unattended overnight runs, the default mode merges each task into a temporary autopilot/<run> branch, then opens one pull request to main for a person to review. A "direct" mode that merges to main exists in the code; we leave it off. [confirm] ship without direct mode
In Nebula Swarm: dev-task-review, dev-autopilot · Enforced by: your branch protection
No direct pushes to main.
Nebula Swarm's rules forbid it, and agents push only task branches. Rules written for an AI aren't a security boundary, so we ask you to protect main: require a pull request and at least one human approval.
In Nebula Swarm: AGENTS.md · Enforced by: your Git host
Isolated branches and worktrees.
Each task runs in its own Git worktree on its own branch, with its own dependencies. A failed or abandoned task can't touch another task's files or your main checkout.
In Nebula Swarm: worktree.sh
An independent reviewer.
A separate reviewer agent, with its own instructions and no memory of writing the code, reviews every change and returns approved or rejected. Rejections go back for fixes before a human sees the pull request. The reviewer uses the same model provider, so it supports human review rather than replacing it.
In Nebula Swarm: dev-task-review, code-reviewer
Unattended runs skip tool prompts.
For overnight runs, Nebula Swarm starts the AI tool in headless mode with its permission prompts turned off, so it can run commands without asking. We recommend running these on a dedicated machine or container that holds only the scoped tokens below. [confirm] our standard setup
In Nebula Swarm: cli_invoke.sh
Secrets stay out of Git.
Tokens live in a gitignored .env file. Nebula Swarm copies it into each task worktree, which is also gitignored. The knowledge graph skips gitignored files. We recommend a secret scanner in CI, scoped tokens over personal ones, and no tokens inside Git remote URLs.
In Nebula Swarm: .gitignore, worktree.sh · Recommended: secret scanning
The Same Gates That Keep the Quality High.
The independent reviewer and the human merge aren't extra settings. They're how Nebula Swarm works: an adversarial review checks every plan before any code and every pull request before it merges, and a person on your team approves the plan and merges into main. The checks that stop an agent shipping on its own are the same ones that catch its mistakes before they merge.
Permissions Nebula Swarm Needs.
| System | What Nebula Swarm does there | Access to grant |
|---|---|---|
| Git host | Push task branches, open pull requests. In unattended runs, create autopilot/* branches and merge task pull requests into them. | Write to the repo and pull requests. No admin and no bypass of main's protection. [confirm] fine-grained token scopes for your host |
| Jira | Search, create, edit, transition, comment and link tickets in the projects you name. | A dedicated account limited to those projects. Jira tokens carry the account's full permissions, so scope the account itself. |
| Confluence | Read pages. | View access to the spaces you choose. Nebula Swarm never writes. |
| Model provider | Every model call, through your AI coding tool. | Your existing seats or API account. We don't need keys of our own. |
| Knowledge graph | Optional. Upsert and query. | An API key for the server, if you enable it. |
What We Access, and What We Leave With: Nothing.
We work in your accounts, on your machines, with access you grant and can take back at any time. There's no Sidera Labs platform to sign up for and no copy of your code on our side.
- During: we use the accounts you provision for us: Git, Jira, Confluence and AI tool seats. [confirm] how engagement access is set up
- We don't take: source code, tickets, documents, prompts or model output. None of it is sent to us by Nebula Swarm.
- We don't hold: your tokens. They stay in your
.envfiles and your secret store. - At the end: you remove our accounts. Nebula Swarm's files stay in your repo and belong to you.
- Telemetry: not pointed at us unless you agree in writing. [confirm]
The Paperwork.
SOC 2
[status] Because your code and data stay in your systems, your existing controls cover them.
DPA
Available on request. [confirm]
Model data terms
Your agreement with your model provider governs prompts and code. Nebula Swarm adds no other AI vendor.
Subprocessors
None that receive your code. [confirm] list for business data
Send Us Your Security Questionnaire.
We'll fill it in with our engineers, not a sales team, and point to the exact script behind each answer. If you'd rather read the code yourself, we'll walk your team through every file that makes a network call.