nomarmy 0.1.0-alpha.1 → 0.1.0-alpha.2

package/README.md

@@ -19,6 +19,7 @@
    ./install.sh --profile macbook-pro   # or nvidia-linux, cpu-linux, dgx-spark, bedrock
    ./e2e.sh --profile macbook-pro       # should end with: === E2E PASS ===
    ```
+   No local model? See [hosted workers only](#hosted-workers-only) or [a shared model server](#a-shared-model-server).
 3. **Set up your repo:** in the project, run `nomarmy init`. It proposes a `.nomarmy.yml` with your test command.
 4. **Use it:** restart Claude Code in that project and ask it to use nomArmy for one small bug that has a test. When that works, try `/feature <what you want built>`.
 5. **Optional:** add hosted workers with `nomarmy agents add`, give roles to them with `nomarmy army init`, or connect Codex or Cursor with `nomarmy connect codex cursor`.
@@ -53,13 +54,15 @@ Around that core: **agents** say where a job can run, the **army** says which ro
 | Linux, with or without an NVIDIA GPU | [Linux](#linux) |
 | Windows | [Windows](#windows) |
 | NVIDIA DGX Spark | [DGX Spark](#dgx-spark) |
-| No GPU, or no local inference | [Cloud (Bedrock)](#cloud-bedrock) |
+| No local model: API keys and subscriptions only | [Hosted workers only](#hosted-workers-only) |
+| A shared GPU server (or a tunnel to one) | [A shared model server](#a-shared-model-server) |
+| No GPU, with Bedrock | [Cloud (Bedrock)](#cloud-bedrock) |
 
 Every platform needs Git and Podman. `nomarmy doctor` checks the host and prints a fix for anything missing.
 
 `install.sh` builds llama.cpp for local inference, installs and configures [OpenClaw](https://github.com/openclaw/openclaw) (the host-side broker every model call goes through), builds the sandbox image, and registers the MCP server if Claude Code is installed. `nomarmy connect` (run by `install.sh`, or by hand for Codex and Cursor) also installs the `/feature` command, Claude Code's status line and, on macOS, nomArmy's notifier. The coordinator gets nomArmy's instructions from the MCP server itself, so there's nothing to copy into your projects.
 
-**From npm:** `npm install -g nomarmy@alpha` gives you the `nomarmy` command; `nomarmy setup` then picks a profile and model and prints the `install.sh` command to run. Installing from a clone, as in the TL;DR, is the most tested path.
+**From npm:** `npm install -g nomarmy@alpha` gives you the `nomarmy` command; `nomarmy setup` then picks a profile and model and prints the `install.sh` command to run (`nomarmy setup --hosted` or `--llama-url <server>` without a local model). Installing from a clone, as in the TL;DR, is the most tested path.
 
 ### macOS (Apple Silicon)
 
@@ -103,7 +106,7 @@ CPU-only Linux works but is slow for interactive use: see [Sizing](#sizing).
 
 1. **WSL2** (the supported path): install a Linux distro under WSL2, install Podman inside it, and follow the [Linux](#linux) guide entirely inside the distro. Watch WSL2's default cap of about half your RAM (`.wslconfig`), and set `git config --global core.longpaths true` (`nomarmy doctor` checks this).
 2. **Native llama.cpp on Windows**, built from source: more RAM, more setup. Prebuilt binaries aren't a safe shortcut; some CPUs crash every backend at startup.
-3. **No local inference**: `./install.sh --profile bedrock` (see [Cloud (Bedrock)](#cloud-bedrock)), or hosted agents only.
+3. **No local inference**: [hosted workers only](#hosted-workers-only), or [Bedrock](#cloud-bedrock).
 
 `nomarmy sizing` reports what your hardware can support.
 
@@ -119,6 +122,34 @@ chmod +x install.sh e2e.sh scripts/*.sh
 
 Moving from a Mac install? Don't copy a Mac binary or model cache over: clone fresh and let `install.sh` build llama.cpp for CUDA on that machine.
 
+### Hosted workers only
+
+No GPU and no local model: every job runs on an API key or a subscription (ChatGPT, Muse Code) you add as an agent. Git worktrees, the sandbox and verification still run on your machine, so you still need Git, Node and Podman.
+
+```bash
+git clone https://github.com/rayson-tech/nomarmy.git && cd nomarmy
+npm install && npm link              # or: npm install -g nomarmy@alpha
+nomarmy setup --hosted               # records that this install has no local model
+./install.sh --profile hosted        # OpenClaw, the sandbox, and the Claude Code registration; no llama.cpp
+nomarmy agents add                   # an API key or a subscription login
+nomarmy army init --agent <name>     # every role on that agent (add --model <model> to pick one)
+nomarmy doctor
+```
+
+A hosted install refuses a job that names no role or agent, rather than falling back to a local model that isn't there. `nomarmy health` warns about any role still on `local`. `e2e.sh` tests the local model, so it has nothing to do here; `nomarmy army assign` tests each role's route instead.
+
+### A shared model server
+
+A team GPU box (a DGX, a workstation) runs one llama-server; everyone else points nomArmy at it. That works through an SSH tunnel too (`ssh -L 8080:localhost:8080 gpu-box`, then `http://127.0.0.1:8080`).
+
+```bash
+nomarmy setup --llama-url http://gpu-box:8080   # checks /health, records the address
+./install.sh --profile remote                   # no llama.cpp build; OpenClaw points at that server
+./e2e.sh --profile remote
+```
+
+nomArmy doesn't start, stop or size that server: whoever runs it sets its model, context and slots, and `install.sh` reads the model name and context from the server. Your machine still runs the sandbox and verification for your jobs. Several people sharing one server share its slots, so keep `NOMARMY_MAX_WORKERS` low (the profile sets 1). Run the server itself with any local profile's `install.sh` on the GPU machine, with `NOMARMY_LLAMA_HOST=0.0.0.0` so others can reach it, on a network you trust: llama-server has no authentication.
+
 ### Cloud (Bedrock)
 
 No GPU, no local build:
@@ -470,7 +501,7 @@ What we've learned from real runs, including where delegating pays and where it
 - **Deploy-time failures need your own check.** See [Add a check for what unit tests can't see](#nomarmyyml).
 - **Node dependencies install only from npm lockfiles**, one per package (no workspaces, yarn, pnpm or bun yet), and only from the public registry: the image build has no credentials for a private one.
 - **Verification needing services** (a database, a mock server) reports `not_run` instead of running without them. The compose parser doesn't resolve YAML anchors.
-- **Same-host only**: the MCP server and OpenClaw run on the machine with the coordinator. There's no remote-worker mode yet.
+- **Same-host sandboxes**: the MCP server, OpenClaw and every job's sandbox run on the machine with the coordinator. Only the model can be elsewhere (an agent, or [a shared model server](#a-shared-model-server)).
 
 ## Troubleshooting
 

package/bin/nomarmy.mjs

@@ -18,10 +18,11 @@ import { buildConfigProposal } from "../lib/propose.mjs";
 import { detectHardware } from "../lib/hardware.mjs";
 import { readGGUFMetadata, resolveModelPath, totalSplitBytes } from "../lib/gguf.mjs";
 import { recommend, customRecommendation, evaluateConfig, bytesPerKvElementForCacheTypes, MIN_CONTEXT_PER_NOM } from "../lib/sizing.mjs";
-import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected } from "../lib/connect.mjs";
+import { connectClaude, connectCodex, connectCursor, cursorAlreadyConnected, deriveWorkerModelEnv } from "../lib/connect.mjs";
 import { ID_RE, AUTH_ENV_NAME_RE, OPENCLAW_PROVIDER_ID_RE, openclawProviderId, isNativeProviderType } from "../lib/dispatch-schema.mjs";
-import { loadAgents, readAgentsFile, writeAgentsFile, agentsConfigPath, apiAgentAsPoolEntry, describeAgent as describeAgentLabel, AGENT_KINDS, API_PROVIDER_TYPES, RESERVED_AGENT_NAMES, BUILTIN_LOCAL_AGENT } from "../lib/agents.mjs";
+import { loadAgents, readAgentsFile, writeAgentsFile, agentsConfigPath, apiAgentAsPoolEntry, describeAgent as describeAgentLabel, agentRunsToolsOnHost, AGENT_KINDS, API_PROVIDER_TYPES, RESERVED_AGENT_NAMES, BUILTIN_LOCAL_AGENT } from "../lib/agents.mjs";
 import { loadArmy, describeArmy, readArmyFile, updateArmyInFile, assignRoleInFile, parseTargetSpec, armyLayerPath, globalConfigDir, DEFAULT_ARMY, ARMY_PHASES, LOCAL_CONFIG_FILENAME } from "../lib/army.mjs";
+import { parseLlamaUrl } from "../lib/execution.mjs";
 import { ensureProviderConfig } from "../lib/openclaw-config.mjs";
 import { recordProbeSuccess } from "../lib/health.mjs";
 import { pruneJobRuntime } from "../lib/prune.mjs";
@@ -93,6 +94,8 @@ Usage: nomarmy <command> [options]
                   write config/profiles/<name>.env (+ config/common.env).
                   Prints the install.sh command; never runs it.
                   --tier <more|nominal>   with --json, skip the prompt
+                  --hosted               skip hardware/model questions
+                  --llama-url <url>       use a llama-server on another machine
   model           Change the configured model later, without the rest of
                   setup's questions. Offers to also resync the MCP
                   registration's worker-routing env vars, and to restart
@@ -168,7 +171,9 @@ Usage: nomarmy <command> [options]
                             UI/UX, data architect, security analyst, PM,
                             PO, stakeholder, all on \`local\`) to --global
                             (default), --project or --local; --force
-                            replaces an existing one
+                            replaces an existing one; --agent <name>
+                            starts every role there, optionally with
+                            --model <model|auto>
                   assign <role> <agent|none> [model|auto]
                             give a role an agent, and optionally the model
                             to run on it ("auto" lets the General pick per
@@ -516,6 +521,55 @@ async function chooseModel(rl) {
  * command itself does.
  */
 async function cmdSetup() {
+  const hosted = flag("hosted");
+  const hasLlamaUrl = flag("llama-url");
+  if (hosted && hasLlamaUrl) throw new Error("--hosted and --llama-url cannot be used together.");
+
+  if (hosted || hasLlamaUrl) {
+    const commonPath = path.join(nomarmyRoot, "config", "common.env");
+
+    if (hosted) {
+      const next = [
+        `${path.join(nomarmyRoot, "install.sh")} --profile hosted`,
+        "nomarmy agents add",
+        "nomarmy army init --agent <name>",
+      ];
+      fs.mkdirSync(path.dirname(commonPath), { recursive: true });
+      writeEnvLine(commonPath, "NOMARMY_EXECUTION", "hosted");
+      if (json) return out({ written: commonPath, execution: "hosted", next });
+      console.log(c.green(`✓ Wrote NOMARMY_EXECUTION=hosted to ${path.relative(nomarmyRoot, commonPath)}.`));
+      console.log(c.dim("\nNext:"));
+      for (const step of next) console.log(`  ${c.bold(step)}`);
+      return;
+    }
+
+    const llamaInput = value("llama-url");
+    if (!llamaInput) throw new Error("--llama-url requires an http:// URL, for example http://server:8080.");
+    const { host: llamaHost, port: llamaPort } = parseLlamaUrl(llamaInput);
+    const urlHost = llamaHost.includes(":") ? `[${llamaHost}]` : llamaHost;
+    const healthUrl = `http://${urlHost}:${llamaPort}/health`;
+    let reachable = false;
+    try {
+      await fetch(healthUrl, { signal: AbortSignal.timeout(5000) });
+      reachable = true;
+    } catch {
+      // A server may simply be offline during setup; retain its validated address.
+    }
+    fs.mkdirSync(path.dirname(commonPath), { recursive: true });
+    writeEnvLine(commonPath, "NOMARMY_EXECUTION", "remote");
+    writeEnvLine(commonPath, "NOMARMY_LLAMA_HOST", llamaHost);
+    writeEnvLine(commonPath, "NOMARMY_LLAMA_PORT", llamaPort);
+    const next = `${path.join(nomarmyRoot, "install.sh")} --profile remote`;
+    if (json) return out({ written: commonPath, execution: "remote", llamaHost, llamaPort, reachable, next });
+    console.log(reachable
+      ? c.green(`✓ llama-server is reachable at ${healthUrl}.`)
+      : c.yellow(`⚠ llama-server is not reachable at ${healthUrl} right now; configuration was still written.`));
+    console.log(c.green(`✓ Wrote the remote llama-server settings to ${path.relative(nomarmyRoot, commonPath)}.`));
+    console.log(c.dim("\nNext:"));
+    console.log(`  ${c.bold(next)}`);
+    return;
+  }
+
   const execution = value("execution", process.env.NOMARMY_EXECUTION || "local");
   const isCloud = execution !== "local";
   const hardware = isCloud ? null : await detectHardware();
@@ -1962,16 +2016,45 @@ async function cmdArmyShow() {
 async function cmdArmyInit() {
   const layer = armyLayerFlag("global");
   const filePath = armyLayerPath(layer, { projectDir: repoDir });
+  const agentName = value("agent");
+  let selectedAgent = null;
+  let roleModel = null;
+  if (flag("agent") && !agentName) throw new Error("--agent requires a name from agents.yml.");
+  if (agentName) {
+    const agents = loadAgentsOrExit().agents;
+    if (!Object.prototype.hasOwnProperty.call(agents, agentName)) {
+      throw new Error(`Unknown agent "${agentName}". Pick one of: ${Object.keys(agents).join(", ")}`);
+    }
+    selectedAgent = agents[agentName];
+    if (flag("model") && !value("model")) throw new Error("--model requires a model name or auto.");
+    roleModel = value("model") ?? (selectedAgent.model ? null : "auto");
+  }
   const existing = readArmyFile(filePath, { armyOnly: layer !== "project" });
   if (existing?.roles && Object.keys(existing.roles).length && !flag("force")) {
     throw new Error(`${filePath} already defines an army (${Object.keys(existing.roles).join(", ")}). Re-run with --force to replace it.`);
   }
   // Keep a General already defined in this layer; the roster is what init resets.
-  updateArmyInFile(filePath, (army) => ({ ...structuredClone(DEFAULT_ARMY), ...(army.general ? { general: army.general } : {}) }));
+  const roster = structuredClone(DEFAULT_ARMY);
+  if (agentName) {
+    for (const role of Object.values(roster.roles)) {
+      role.agent = agentName;
+      if (roleModel) role.model = roleModel;
+    }
+  }
+  updateArmyInFile(filePath, (army) => ({ ...roster, ...(army.general ? { general: army.general } : {}) }));
   if (layer === "local") ensureLocalLayerIgnored();
   if (json) return out({ written: filePath, layer, roles: Object.keys(DEFAULT_ARMY.roles) });
   console.log(c.green(`✓ Wrote the default army to ${filePath} (${layer}).`));
-  console.log(c.dim("Every role starts on the local model. Next: `nomarmy army general <agent>` (the agent your coordinator session runs on), then `nomarmy army assign <role> <agent>` for any role you want elsewhere."));
+  if (!agentName) {
+    console.log(c.dim("Every role starts on the local model. Next: `nomarmy army general <agent>` (the agent your coordinator session runs on), then `nomarmy army assign <role> <agent>` for any role you want elsewhere."));
+    return;
+  }
+  console.log(c.dim(roleModel === "auto"
+    ? `Every role starts on ${agentName} with model auto; the coordinator picks a model per job.`
+    : `Every role starts on ${agentName}${roleModel ? ` with model ${roleModel}` : ` using its default model ${selectedAgent.model}`}.`));
+  if (agentRunsToolsOnHost(selectedAgent)) {
+    console.log(c.yellow(`⚠ ${agentName} runs its tools on the host. Build roles on it will be refused unless allow_host_tools is set in agents.yml.`));
+  }
 }
 
 async function cmdArmyAssign() {
@@ -2206,10 +2289,18 @@ async function cmdJobs() {
 
 // `nomarmy health`: run the checks now (the MCP server also runs them every
 // 6 hours) and record them, which also refreshes the status line's warning.
+// This install's settings from config/common.env (the execution mode and the
+// model server's address, as `nomarmy connect` gives the MCP server), under
+// anything set (non-empty) in the environment.
+function installEnv() {
+  const set = Object.fromEntries(Object.entries(process.env).filter(([, v]) => v !== ""));
+  return { ...deriveWorkerModelEnv(nomarmyRoot), ...set };
+}
+
 async function cmdHealth() {
   const { checkAndRecordHealth } = await import("../lib/health.mjs");
   const stateRoot = process.env.NOMARMY_AGENT_STATE || path.join(os.homedir(), ".local", "share", "nomarmy-local-agents");
-  const { result } = await checkAndRecordHealth({ projectDir: repoDir, stateRoot, configDir: globalConfigDir() });
+  const { result } = await checkAndRecordHealth({ projectDir: repoDir, stateRoot, configDir: globalConfigDir(), env: installEnv() });
   if (json) return out(result);
   console.log(c.bold("🍪 nomArmy health") + c.dim(`  ${new Date(result.checkedAt).toLocaleString()}`));
   if (!result.issues.length) { console.log(c.green("\n✓ Nothing to fix.")); return; }
@@ -2234,7 +2325,7 @@ const commands = { scan: cmdScan, validate: cmdValidate, sizing: cmdSizing, init
 async function cmdDoctor() {
   // Import lazily to avoid circular dependencies
   const { runDoctor } = await import("../lib/doctor.mjs");
-  await runDoctor({ json, exit: true });
+  await runDoctor({ json, exit: true, env: installEnv() });
 }
 commands.doctor = cmdDoctor;
 if (!command || flag("help") || !commands[command]) usage(command && !commands[command] ? 2 : 0);

package/config/common.env

@@ -16,8 +16,10 @@ NOMARMY_MAX_WORKERS=1
 NOMARMY_AGENT_IMAGE=openclaw-nomarmy-coder:bookworm
 NOMARMY_INSTALL_ROOT=$HOME/.local/share/nomarmy-local-agents
 
-# Execution layer: 'local' runs llama-server on this machine, 'bedrock' calls a
-# hosted OpenAI-compatible endpoint. Profiles override this.
+# Where models run: 'local' runs llama-server on this machine, 'remote' uses
+# one nomArmy doesn't run (nomarmy setup --llama-url), 'hosted' has no local
+# model at all (nomarmy setup --hosted), 'bedrock' calls Bedrock. Profiles
+# override this.
 NOMARMY_EXECUTION=local
 
 # Worker model routing. The MCP server composes "<provider>/<model>" for

package/config/profiles/hosted.env

@@ -0,0 +1,6 @@
+# Hosted workers only: no local model on this machine. Every job runs on an
+# api or subscription agent (nomarmy agents add); the sandbox, git worktrees
+# and verification still run here. `nomarmy setup --hosted` writes this
+# mode into config/common.env as well, so the MCP server knows it.
+NOMARMY_PROFILE=hosted
+NOMARMY_EXECUTION=hosted

package/config/profiles/remote.env

@@ -0,0 +1,9 @@
+# A llama-server nomArmy doesn't run, e.g. a team's GPU server or an SSH
+# tunnel to one. Set its address with `nomarmy setup --llama-url
+# http://host:8080`, which writes NOMARMY_LLAMA_HOST / NOMARMY_LLAMA_PORT
+# into config/common.env. nomArmy
+# doesn't start, stop or size that server; the sandbox, git worktrees and
+# verification still run on this machine.
+NOMARMY_PROFILE=remote
+NOMARMY_EXECUTION=remote
+NOMARMY_MAX_WORKERS=1

package/e2e.sh

@@ -24,6 +24,12 @@ load_profile "$PROFILE"
 
 echo "=== nomArmy E2E: $NOMARMY_PROFILE ==="
 
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "e2e.sh runs a job on the local model, and profile '$NOMARMY_PROFILE' has none."
+  echo "Check each agent with: nomarmy doctor"
+  exit 0
+fi
+
 "$ROOT/scripts/start-inference.sh" "$NOMARMY_PROFILE"
 
 if nomarmy_is_cloud; then

package/install.sh

@@ -15,7 +15,7 @@ case "$OS_NAME" in
     command -v curl >/dev/null 2>&1 || brew install curl
     command -v git >/dev/null 2>&1 || brew install git
     command -v node >/dev/null 2>&1 || brew install node
-    if ! nomarmy_is_cloud; then
+    if nomarmy_manages_model_server; then
       command -v xcode-select >/dev/null 2>&1 && xcode-select -p >/dev/null 2>&1 || { echo 'ERROR: Xcode Command Line Tools are required. Run: xcode-select --install'; exit 1; }
       command -v cmake >/dev/null 2>&1 || brew install cmake
     fi
@@ -24,8 +24,8 @@ case "$OS_NAME" in
     command -v podman >/dev/null 2>&1 || brew install podman
     ;;
   Linux)
-    if nomarmy_is_cloud; then
-      # No local model is built or served, so the C++ toolchain is not needed.
+    if ! nomarmy_manages_model_server; then
+      # No model is built or served here, so the C++ toolchain is not needed.
       need curl; need git; need node; need npm
     else
       if ! command -v cmake >/dev/null 2>&1 || ! command -v c++ >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1 || ! command -v git >/dev/null 2>&1 || ! command -v node >/dev/null 2>&1 || ! command -v npm >/dev/null 2>&1; then install_build_dependencies; fi
@@ -105,7 +105,7 @@ if ! command -v openclaw >/dev/null 2>&1; then
   export PATH="$HOME/.local/bin:$HOME/.npm-global/bin:$PATH"
 fi
 need openclaw
-if ! nomarmy_is_cloud; then openclaw plugins install @openclaw/llama-cpp-provider || true; fi
+if nomarmy_has_local_model; then openclaw plugins install @openclaw/llama-cpp-provider || true; fi
 "$ROOT/scripts/start-inference.sh" "$NOMARMY_PROFILE"
 # Sandbox before provider config: configure-openclaw.sh refuses to store a real
 # Bedrock credential unless the coder sandbox is already network-isolated.
@@ -122,4 +122,8 @@ if nomarmy_is_cloud && [[ "${NOMARMY_ORCHESTRATOR_RUNTIME:-}" == "claude-code" ]
   echo "    ./scripts/configure-orchestrator.sh $NOMARMY_PROFILE          # print the settings"
   echo "    ./scripts/configure-orchestrator.sh $NOMARMY_PROFILE --apply  # write them to Claude Code"
 fi
-echo "==> Install complete. Run: ./e2e.sh --profile $NOMARMY_PROFILE"
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "==> Install complete. Add an agent (nomarmy agents add), give roles to it (nomarmy army init --agent <name>), then run: nomarmy doctor"
+else
+  echo "==> Install complete. Run: ./e2e.sh --profile $NOMARMY_PROFILE"
+fi

package/lib/admission.mjs

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { executionMode } from "./execution.mjs";
 import { clampInt } from "./budget-state.mjs";
 import { checkBrief, assessAdmission, describeBudgets } from "./budget.mjs";
 import { parseStatusPorcelainZ, isRuntimeJunk } from "./git-record.mjs";
@@ -147,8 +148,11 @@ export function createJobRuntime(deps) {
     const ok = !error && (result?.ok || m.coordinatorStatus === "complete");
     notify(`nomArmy: ${entry.role ?? entry.mode ?? "job"} ${ok ? "done" : outcome}`, `${entry.workerId ?? entry.jobId} on ${who}: ${outcome} after ${took}m. ${ok ? "Ready for the General's review." : "Needs a look."}`);
   }
+  function admissionHardware() {
+    return executionMode(deps.env).managesModelServer ? deps.budgetState.hardwareSnapshot : null;
+  }
   function capacitySnapshot() {
-    const admission = assessAdmission({ hardware: deps.budgetState.hardwareSnapshot, runningJobs: runningCount("local"), slots: deps.budgetState.contextInfo.slots, maxWorkers: currentMaxWorkers() });
+    const admission = assessAdmission({ hardware: admissionHardware(), runningJobs: runningCount("local"), slots: deps.budgetState.contextInfo.slots, maxWorkers: currentMaxWorkers() });
     return {
       // The local model's budget. An api or subscription job's scales with
       // its own model; local_worker_start reports that job's.
@@ -241,14 +245,16 @@ export function createJobRuntime(deps) {
       } catch (error) { problems.push(jobs.length > 1 ? `job ${i + 1}: ${error.message}` : error.message); }
     });
     // Slot capacity only concerns local jobs: a remote job's inference runs
-    // at its vendor and never competes for llama-server's slots. Free memory
-    // still applies to every job (each one runs a local sandbox), so a
-    // remote-only batch is checked for memory alone. Remote jobs have their
-    // own, additive ceiling (currentMaxPoolWorkers).
+    // at its vendor and never competes for llama-server's slots. When this
+    // install runs llama-server itself, free memory applies to every job
+    // (the model and each job's sandbox share it), so a remote-only batch is
+    // checked for memory alone. A remote or hosted install has no model
+    // here to size memory against. Remote jobs have their own, additive
+    // ceiling (currentMaxPoolWorkers).
     const anyLocal = jobs.some((j) => jobLane(j) === "local");
     const admission = anyLocal
-      ? assessAdmission({ hardware: deps.budgetState.hardwareSnapshot, runningJobs: runningCount("local"), slots: deps.budgetState.contextInfo.slots, maxWorkers: currentMaxWorkers() })
-      : assessAdmission({ hardware: deps.budgetState.hardwareSnapshot, runningJobs: 0, slots: null, maxWorkers: Infinity });
+      ? assessAdmission({ hardware: admissionHardware(), runningJobs: runningCount("local"), slots: deps.budgetState.contextInfo.slots, maxWorkers: currentMaxWorkers() })
+      : assessAdmission({ hardware: admissionHardware(), runningJobs: 0, slots: null, maxWorkers: Infinity });
     if (!admission.admit) problems.push(...admission.reasons.map(r => `not admitted (${admission.level}): ${r}`));
     if (jobs.some((j) => jobLane(j) === "remote")) {
       const remoteCeiling = currentMaxPoolWorkers(), runningRemote = runningCount("remote");

package/lib/budget-state.mjs

@@ -1,4 +1,5 @@
 import { deriveBudgets, resolveContextPerNom } from "./budget.mjs";
+import { executionMode } from "./execution.mjs";
 
 export function clampInt(value, min, max, fallback) {
   const n = Number.parseInt(value ?? "", 10);
@@ -12,8 +13,10 @@ export function createBudgetState({ env = process.env } = {}) {
   function currentBudgets() { return budgets; }
   async function refresh() {
     try {
-      contextInfo = await resolveContextPerNom({ env });
-      budgets = deriveBudgets({ contextPerNom: contextInfo.contextPerNom, source: contextInfo.source, env });
+      if (executionMode(env).hasLocalModel) {
+        contextInfo = await resolveContextPerNom({ env });
+        budgets = deriveBudgets({ contextPerNom: contextInfo.contextPerNom, source: contextInfo.source, env });
+      }
     } catch { /* keep the previous budgets; a failed probe is not a reason to refuse work */ }
     try {
       const { detectHardware } = await import("./hardware.mjs");

package/lib/budget.mjs

@@ -16,6 +16,7 @@
 // Everything here is pure except `resolveContextPerNom`, which may ask a
 // running llama-server what its slots actually are; the probe is injectable.
 import { DEFAULT_TARGET_CONTEXT_PER_NOM, MIN_CONTEXT_PER_NOM, RESERVES, GIB, formatBytes, isCloudExecution } from "./sizing.mjs";
+import { executionMode } from "./execution.mjs";
 
 /**
  * Hard ceilings the MCP tool schema enforces regardless of hardware. The
@@ -309,7 +310,9 @@ async function defaultProbe(env) {
 export async function resolveContextPerNom({ env = process.env, probe = defaultProbe } = {}) {
   const direct = envInt(env, "NOMARMY_CONTEXT_PER_NOM");
   if (direct) return { contextPerNom: direct, slots: envInt(env, "NOMARMY_LLAMA_PARALLEL"), source: "profile (NOMARMY_CONTEXT_PER_NOM)" };
-  const total = envInt(env, "NOMARMY_LLAMA_CONTEXT"), parallel = envInt(env, "NOMARMY_LLAMA_PARALLEL");
+  // A remote server's context is its own, not this machine's settings.
+  const remote = executionMode(env).mode === "remote";
+  const total = remote ? null : envInt(env, "NOMARMY_LLAMA_CONTEXT"), parallel = remote ? null : envInt(env, "NOMARMY_LLAMA_PARALLEL");
   if (total && parallel) return { contextPerNom: Math.floor(total / parallel), slots: parallel, source: "profile (NOMARMY_LLAMA_CONTEXT / NOMARMY_LLAMA_PARALLEL)" };
   if (!isCloudExecution(env.NOMARMY_EXECUTION || "local")) {
     const probed = await probe(env);

package/lib/connect.mjs

@@ -240,6 +240,10 @@ export function deriveWorkerModelEnv(nomarmyRoot) {
   const env = {};
   if (model) env.NOMARMY_WORKER_MODEL = model;
   if (thinking !== null) env.NOMARMY_WORKER_MODEL_THINKING = thinking;
+  for (const key of ["NOMARMY_EXECUTION", "NOMARMY_LLAMA_HOST", "NOMARMY_LLAMA_PORT"]) {
+    const value = readEnvValue(commonPath, key);
+    if (value !== null) env[key] = value;
+  }
   return env;
 }
 

package/lib/doctor.mjs

@@ -9,6 +9,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
+import { executionMode } from "./execution.mjs";
 
 const MIN_NODE_MAJOR = 18;
 const DEFAULT_LLAMA_HOST = "127.0.0.1";
@@ -189,11 +190,28 @@ export function checkPodmanDaemon(facts) {
 export function checkEndpoint(facts) {
   const { execution, endpoint } = facts;
   if (execution === "bedrock") return checkBedrockEndpoint(endpoint);
+  if (execution === "hosted") {
+    return {
+      ok: true,
+      message: "No local model by design; jobs run on API and subscription agents (run 'nomarmy agents list' to see them).",
+    };
+  }
+  if (execution === "remote") return checkRemoteEndpoint(endpoint);
   if (execution === "local") return checkLocalEndpoint(endpoint);
   return {
     ok: false,
     message: `NOMARMY_EXECUTION '${execution}' is not recognized.`,
-    fix: "Set NOMARMY_EXECUTION to 'local' or 'bedrock' (see config/common.env).",
+    fix: "Set NOMARMY_EXECUTION to 'local', 'remote', 'hosted', or 'bedrock' (see config/common.env).",
+  };
+}
+
+function checkRemoteEndpoint(endpoint) {
+  const { url, healthy, error } = endpoint;
+  if (healthy) return { ok: true, message: `Remote model server is healthy at ${url}.` };
+  return {
+    ok: false,
+    message: `Remote model server health check failed at ${url}${error ? `: ${error}` : "."}`,
+    fix: "Check that the remote server is running and reachable from this machine, then re-run 'nomarmy doctor'.",
   };
 }
 
@@ -324,6 +342,21 @@ async function probeLocalEndpoint(host, port) {
   }
 }
 
+/** Probe a remotely managed model server's health endpoint. */
+export async function probeRemoteEndpoint(llamaUrl, fetchImpl = fetch) {
+  const url = `${llamaUrl}/health`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 2000);
+  try {
+    const res = await fetchImpl(url, { signal: controller.signal });
+    return { mode: "remote", url, healthy: res.ok, error: res.ok ? null : `HTTP ${res.status}` };
+  } catch (err) {
+    return { mode: "remote", url, healthy: false, error: err.name === "AbortError" ? "timed out" : err.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Gather the (non-network-secret) facts a bedrock profile needs: is a region
  * configured and syntactically valid, and are credentials discoverable at
@@ -344,6 +377,20 @@ function collectBedrockFacts(env) {
   return { mode: "bedrock", region, baseUrl, regionValid, credentialsPresent };
 }
 
+/** Resolve execution mode and collect only its endpoint facts. */
+export async function collectEndpointFacts(env = process.env, fetchImpl = fetch) {
+  const configured = String(env.NOMARMY_EXECUTION || "local").trim().toLowerCase();
+  const resolved = executionMode(env);
+  const execution = ["local", "remote", "hosted", "bedrock"].includes(configured) ? resolved.mode : configured;
+  if (execution === "bedrock") return { execution, endpoint: collectBedrockFacts(env) };
+  if (execution === "hosted") return { execution, endpoint: { mode: "hosted" } };
+  if (execution === "remote") return { execution, endpoint: await probeRemoteEndpoint(resolved.llamaUrl, fetchImpl) };
+  return {
+    execution,
+    endpoint: await probeLocalEndpoint(env.NOMARMY_LLAMA_HOST || DEFAULT_LLAMA_HOST, env.NOMARMY_LLAMA_PORT || DEFAULT_LLAMA_PORT),
+  };
+}
+
 /**
  * Collect every fact the checks need. Side effects only - no decisions here.
  * @param {NodeJS.ProcessEnv} [env]
@@ -382,10 +429,7 @@ export async function collectFacts(env = process.env) {
   const podmanDaemon = podmanPath
     ? await probePodmanDaemon(podmanPath)
     : { reachable: false, error: "podman not found" };
-  const execution = (env.NOMARMY_EXECUTION || "local").trim();
-  const endpoint = execution === "bedrock"
-    ? collectBedrockFacts(env)
-    : await probeLocalEndpoint(env.NOMARMY_LLAMA_HOST || DEFAULT_LLAMA_HOST, env.NOMARMY_LLAMA_PORT || DEFAULT_LLAMA_PORT);
+  const { execution, endpoint } = await collectEndpointFacts(env);
   return {
     nodeVersion: process.version,
     platform,

package/lib/execution.mjs

@@ -0,0 +1,57 @@
+// Where this install's models run, in one place, so the MCP server, doctor,
+// health and the CLI agree.
+//
+//   local    a llama-server on this machine (the default)
+//   remote   a llama-server nomArmy doesn't run, e.g. a team's GPU server or
+//            an SSH tunnel to one: NOMARMY_EXECUTION=remote (what `nomarmy
+//            setup --llama-url` writes), or local with a non-loopback
+//            NOMARMY_LLAMA_HOST
+//   hosted   no local model at all: every job runs on an api or subscription
+//            agent (NOMARMY_EXECUTION=hosted)
+//   bedrock  the Bedrock cloud profile (NOMARMY_EXECUTION=bedrock)
+//
+// Settings come from config/common.env (and a profile), which `nomarmy
+// connect` forwards to the MCP server's environment.
+
+const LOOPBACK = new Set(["127.0.0.1", "localhost", "::1", "[::1]", "0.0.0.0"]);
+
+/** Whether a host name or address points at this machine. */
+export function isLoopbackHost(host) {
+  const h = String(host ?? "").trim().toLowerCase();
+  return h === "" || LOOPBACK.has(h) || /^127\./.test(h);
+}
+
+/**
+ * This install's execution mode.
+ * @returns {{ mode: "local"|"remote"|"hosted"|"bedrock", hasLocalModel: boolean, managesModelServer: boolean, llamaHost: string, llamaPort: string, llamaUrl: string|null }}
+ *   hasLocalModel: jobs can run on the `local` agent (local or remote).
+ *   managesModelServer: nomArmy starts/stops llama-server and sizes it
+ *   against this machine's memory (local only).
+ */
+export function executionMode(env = process.env) {
+  const execution = String(env.NOMARMY_EXECUTION || "local").trim().toLowerCase();
+  const llamaHost = String(env.NOMARMY_LLAMA_HOST || "127.0.0.1").trim();
+  const llamaPort = String(env.NOMARMY_LLAMA_PORT || "8080").trim();
+  const llamaUrl = `http://${llamaHost.includes(":") && !llamaHost.startsWith("[") ? `[${llamaHost}]` : llamaHost}:${llamaPort}`;
+  if (execution === "hosted") return { mode: "hosted", hasLocalModel: false, managesModelServer: false, llamaHost, llamaPort, llamaUrl: null };
+  if (execution === "bedrock") return { mode: "bedrock", hasLocalModel: false, managesModelServer: false, llamaHost, llamaPort, llamaUrl: null };
+  const remote = execution === "remote" || !isLoopbackHost(llamaHost);
+  return { mode: remote ? "remote" : "local", hasLocalModel: true, managesModelServer: !remote, llamaHost, llamaPort, llamaUrl };
+}
+
+/**
+ * Parse a model-server URL given to `nomarmy setup --llama-url` into the
+ * NOMARMY_LLAMA_HOST / NOMARMY_LLAMA_PORT pair. http only (llama-server
+ * speaks plain HTTP; put TLS in front of it and use its host if needed),
+ * port defaulting to 8080. Throws a clear error on anything else.
+ */
+export function parseLlamaUrl(input) {
+  let url;
+  try { url = new URL(String(input ?? "").trim()); } catch { throw new Error(`"${input}" isn't a URL; use the form http://host:8080`); }
+  if (url.protocol !== "http:") throw new Error(`use an http:// URL for llama-server (got ${url.protocol}//)`);
+  if (url.username || url.password) throw new Error("the URL can't carry a username or password");
+  if (url.pathname && url.pathname !== "/") throw new Error(`give the server's address only, without a path (got ${url.pathname})`);
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (!host) throw new Error("the URL has no host");
+  return { host, port: url.port || "8080" };
+}

package/lib/health.mjs

@@ -19,6 +19,7 @@
 import { execFile } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { executionMode } from "./execution.mjs";
 import { modelRejection } from "./openclaw-errors.mjs";
 import { providerConfigured, readOpenclawConfig } from "./openclaw-config.mjs";
 
@@ -70,11 +71,15 @@ export function versionIssues({ installed, latest, plugins = [] }) {
 }
 
 /** Roles, and the General, pointing at something unusable (from describeArmy's summary). */
-export function armyIssues(summary) {
+export function armyIssues(summary, mode = "local") {
   const issues = [];
   if (summary?.general?.problem) issues.push({ id: "army:general", severity: "warn", title: "The General's agent isn't set up", detail: summary.general.problem, fix: "nomarmy army general <agent>", short: null });
   for (const [role, r] of Object.entries(summary?.roles ?? {})) {
     if (r.problem) issues.push({ id: `army:role:${role}:${r.problem}`, severity: "warn", title: `Role ${role} can't be dispatched`, detail: r.problem, fix: `nomarmy army assign ${role} <agent> [model|auto]`, short: `${role} unusable` });
+    else if (mode === "hosted" && r.agent === "local") issues.push({ id: `army:hosted-local:${role}`, severity: "warn",
+      title: `Role ${role} uses the local agent in hosted mode`,
+      detail: "Hosted installs have no local model, so jobs for this role will be refused.",
+      fix: `nomarmy army assign ${role} <agent> [model] or nomarmy army init --agent <name>`, short: `${role} uses local` });
     else if (r.hostTools?.implementRole && !r.hostTools.allowed) issues.push({ id: `army:host-tools:${role}:${r.agent}`, severity: "warn",
       title: `Role ${role} builds on ${r.agent}, whose tools run on this machine`,
       detail: `${r.agent}'s worker runs its own shell on your machine, with your files and the network, outside nomArmy's sandbox, so nomArmy refuses implement jobs on it.`,
@@ -178,7 +183,7 @@ export function leftoverIssues({ retainedWorktrees = 0, jobsBytes = 0, staleRunn
  * Run every check. `env` supplies what each needs, with real defaults;
  * tests pass their own.
  */
-export async function runHealthChecks({ now = Date.now(), openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null } = {}) {
+export async function runHealthChecks({ now = Date.now(), mode = "local", openclawCmd = process.env.NOMARMY_OPENCLAW_CMD || "openclaw", run = runBounded, armySummary = null, agentsError = null, jobsRoot = null, pidAlive = () => true, agents = null, openclawConfig = null, vendors = {}, modelsInUse = null, autoPruned = null } = {}) {
   const issues = [];
   if (autoPruned?.freedBytes) issues.push({ id: `auto-prune:${new Date(now).toISOString()}`, severity: "info",
     title: `Freed ${(autoPruned.freedBytes / 1024 ** 3).toFixed(2)} GB: ${[autoPruned.pruned ? `runtime data of ${autoPruned.pruned} finished job${autoPruned.pruned === 1 ? "" : "s"} older than ${autoPruned.olderThanHours}h` : null, autoPruned.scratchCleared ? `OpenClaw scratch files of ${autoPruned.scratchCleared} more` : null].filter(Boolean).join(", ")}`,
@@ -194,7 +199,7 @@ export async function runHealthChecks({ now = Date.now(), openclawCmd = process.
   const pluginVersion = /Version:\s*(\S+)/.exec(plugins.stdout ?? "")?.[1];
   if (version.ok) issues.push(...versionIssues({ installed: version.stdout, latest: latest.ok ? latest.stdout : null, plugins: pluginVersion ? [{ id: "codex", version: pluginVersion }] : [] }));
   if (agentsError) issues.push({ id: `config:agents:${agentsError}`, severity: "error", title: "agents.yml can't be loaded", detail: agentsError, fix: "nomarmy agents list (shows the problem)", short: "agents.yml broken" });
-  if (armySummary) issues.push(...armyIssues(armySummary));
+  if (armySummary) issues.push(...armyIssues(armySummary, mode));
   if (jobsRoot) {
     let retainedWorktrees = 0, jobsBytes = 0, staleRunning = 0;
     const records = [];
@@ -245,7 +250,7 @@ export function recordHealth(file, result, { now = Date.now() } = {}) {
  * periodic run and `nomarmy health`, then run and recorded to the shared
  * health.json. Returns { result, toNotify }.
  */
-export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, now = Date.now() }) {
+export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, now = Date.now(), env = process.env }) {
   const { loadAgents, describeAgent, agentProviderId } = await import("./agents.mjs");
   const { loadArmy, describeArmy } = await import("./army.mjs");
   const { pidAlive } = await import("./slots.mjs");
@@ -271,7 +276,8 @@ export async function checkAndRecordHealth({ projectDir, stateRoot, configDir, n
   const ageMs = autoPruneAgeMs();
   let autoPruned = null;
   if (ageMs !== null) { try { autoPruned = { ...pruneJobRuntime({ stateRoot, olderThanMs: ageMs, now }), olderThanHours: ageMs / 3600000 }; } catch { /* best-effort */ } }
-  const result = await runHealthChecks({ now, armySummary, agentsError, jobsRoot: path.join(stateRoot, "jobs"), pidAlive,
+  const mode = executionMode(env).mode;
+  const result = await runHealthChecks({ now, mode, armySummary, agentsError, jobsRoot: path.join(stateRoot, "jobs"), pidAlive,
     agents, openclawConfig: readOpenclawConfig(), vendors: SUBSCRIPTION_VENDORS, modelsInUse, autoPruned });
   const toNotify = recordHealth(path.join(stateRoot, "health.json"), result, { now });
   return { result, toNotify };

package/mcp/server.mjs

@@ -1,6 +1,7 @@
 import { createJobRuntime, jobLane, currentMaxPoolWorkers, splitJobsByLane, toolText, refusalText } from "../lib/admission.mjs";
 export { jobLane, currentMaxPoolWorkers, splitJobsByLane, refusalText };
 import { createExecutor, sleep } from "../lib/execute.mjs";
+import { executionMode } from "../lib/execution.mjs";
 export { JOB_PHASES } from "../lib/execute.mjs";
 import { createVerificationFlow } from "../lib/verification-flow.mjs";
 export { gitShowBuffer, gitModeAtBase, planProductionRevert, revertToBase, restoreWorkerVersion, blobHash, currentBlobHash } from "../lib/verification-flow.mjs";
@@ -207,7 +208,7 @@ export function makeHeartbeatTick(jobDir) { return heartbeatTick(jobDir, livePro
 // Senti run none were tagged, so a 4-hour run went 8.46 hours unchecked.
 let activeRunId = null;
 
-export function expandJobs(jobs, { getArmy = currentArmy, getAgents = () => agentsConfig().agents, getActiveRun = () => activeRunId } = {}) {
+export function expandJobs(jobs, { getArmy = currentArmy, getAgents = () => agentsConfig().agents, getActiveRun = () => activeRunId, env = process.env } = {}) {
   const problems = [];
   let army = null, agents = null;
   const runId = getActiveRun();
@@ -217,6 +218,7 @@ export function expandJobs(jobs, { getArmy = currentArmy, getAgents = () => agen
       if (j.army_role) { army ??= getArmy().army; j = expandArmyRole(j, army); }
       const { agent, roleModel = null, ...rest } = j;
       if (!agent) {
+        if (executionMode(env).mode === "hosted") throw new Error("this install has no local model (NOMARMY_EXECUTION=hosted): give the job an army_role or an agent (the army tool lists them)");
         if (rest.model) throw new Error(`model "${rest.model}" needs an agent to run on: add agent (or army_role), or drop model to use the local model`);
         return { ...rest, profile: rest.profile ?? "coder" };
       }
@@ -254,7 +256,7 @@ export { executeJob };
 
 const { WORKER_START_STAGGER_MS, activeJobs, runningCount, agentMaxConcurrent, withAgentSlot, track, notifyJobFinished, capacitySnapshot, admit, refusal, runBrief, recordJobInRun, trackInRun, launch, liveProgress, summarize } = createJobRuntime({
   projectDir, stateRoot, jobsRoot, runsRoot, leasesRoot, slotsRoot, run, currentMaxWorkers, slug, agentsConfig, modelCatalogReady, budgetsForJob, resolveSubscriptionSelection, executeJob, subscriptionJobFieldProblems, repoPolicy, jobArgs,
-  budgetState, getActiveRunId: () => activeRunId,
+  env: process.env, budgetState, getActiveRunId: () => activeRunId,
 });
 export { runningCount, track };
 

package/package.json

@@ -3,7 +3,7 @@
   "description": "A harness for AI coding workers whose claims are never trusted: your coding assistant stays in charge while workers implement and test in sandboxes, on local models, API keys or your own subscriptions.",
   "author": "Rayson Technologies",
   "license": "Apache-2.0",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "private": false,
   "type": "module",
   "engines": {

package/scripts/configure-openclaw.sh

@@ -2,6 +2,14 @@
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; source "$ROOT/scripts/lib.sh"; load_profile "${1:-}"
 
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  # No model provider to register: each api or subscription agent is set up
+  # with `nomarmy agents add`, which configures its own OpenClaw provider.
+  echo "Profile '$NOMARMY_PROFILE' runs every job on an api or subscription agent; no local model provider to configure."
+  echo "Add one with: nomarmy agents add"
+  exit 0
+fi
+
 PROVIDER="$NOMARMY_WORKER_PROVIDER"
 PROFILE_ID="$PROVIDER:nomarmy-$NOMARMY_PROFILE"
 
@@ -39,7 +47,34 @@ else
   MODEL_ID="$NOMARMY_MODEL_ALIAS"
   AUTH_CHOICE="llama-cpp-existing-server"
   PROFILE_ID="llama-cpp:nomarmy-local"
-  echo "==> Configuring OpenClaw against local llama-server, model $MODEL_ID"
+  if [[ "$(nomarmy_execution_mode)" == remote ]]; then
+    # Someone else runs this server, so its model name and context come from
+    # the server itself rather than this machine's settings.
+    SERVER="http://$NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT"
+    curl -fsS --max-time 5 "$SERVER/health" >/dev/null || { echo "ERROR: no llama-server answering at $SERVER/health. Set its address with: nomarmy setup --llama-url http://<host>:8080" >&2; exit 1; }
+    REMOTE_MODEL="$(curl -fsS --max-time 5 "$SERVER/v1/models" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).data?.[0]?.id??"")}catch{}})' || true)"
+    [[ -n "$REMOTE_MODEL" ]] && MODEL_ID="$REMOTE_MODEL"
+    if [[ -n "$REMOTE_MODEL" && "$REMOTE_MODEL" != "${NOMARMY_WORKER_MODEL:-}" ]]; then
+      # Jobs ask for NOMARMY_WORKER_MODEL, so record the name this server
+      # actually serves (`nomarmy connect`, run next by install.sh, reads it).
+      COMMON="$ROOT/config/common.env"
+      for key in NOMARMY_MODEL_ALIAS NOMARMY_WORKER_MODEL; do
+        if grep -q "^$key=" "$COMMON"; then
+          KEY="$key" VALUE="$REMOTE_MODEL" node -e 'const fs=require("fs"),f=process.argv[1];fs.writeFileSync(f,fs.readFileSync(f,"utf8").replace(new RegExp(`^${process.env.KEY}=.*$`,"m"),`${process.env.KEY}=${process.env.VALUE}`))' "$COMMON"
+        else
+          printf '%s=%s\n' "$key" "$REMOTE_MODEL" >>"$COMMON"
+        fi
+      done
+      export NOMARMY_MODEL_ALIAS="$REMOTE_MODEL" NOMARMY_WORKER_MODEL="$REMOTE_MODEL"
+      echo "==> The server serves '$REMOTE_MODEL'; recorded it in config/common.env"
+    fi
+    # llama-server reports the context of one slot, which is one nom's share.
+    REMOTE_CTX="$(curl -fsS --max-time 5 "$SERVER/props" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const n=JSON.parse(s).default_generation_settings?.n_ctx;if(Number.isInteger(n)&&n>0)process.stdout.write(String(n))}catch{}})' || true)"
+    [[ -n "$REMOTE_CTX" ]] && export NOMARMY_CONTEXT_PER_NOM="$REMOTE_CTX"
+    echo "==> Configuring OpenClaw against the llama-server at $SERVER, model $MODEL_ID${REMOTE_CTX:+, context $REMOTE_CTX per nom}"
+  else
+    echo "==> Configuring OpenClaw against local llama-server, model $MODEL_ID"
+  fi
 fi
 
 openclaw onboard --non-interactive --accept-risk \
@@ -61,9 +96,10 @@ if ! nomarmy_is_cloud; then
   # against a freshly-resized 65536-token nom still overflowed at ~20K tokens
   # of prompt, on literally the first turn, because OpenClaw was still
   # enforcing its onboarding-time guess. NOMARMY_CONTEXT_PER_NOM (exported by
-  # nomarmy_validate_local, above, in load_profile) is nomArmy's own already-
-  # computed truth for this exact number; write it back so OpenClaw's model
-  # registration cannot drift from the server it is actually talking to.
+  # nomarmy_validate_local, above, in load_profile, or read from a remote
+  # server's /props) is nomArmy's own already-computed truth for this exact
+  # number; write it back so OpenClaw's model registration cannot drift from
+  # the server it is actually talking to.
   # models[0] assumes exactly the one custom local model this script just
   # onboarded, which is what onboard --custom-model-id always produces here.
   CONTEXT_WINDOW="${NOMARMY_CONTEXT_PER_NOM:-24576}"

package/scripts/install-llama-cpp.sh

@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; source "$ROOT/scripts/lib.sh"; load_profile "${1:-}"
-if nomarmy_is_cloud; then echo "Profile '$NOMARMY_PROFILE' uses hosted inference; skipping llama.cpp build."; exit 0; fi
+if ! nomarmy_manages_model_server; then
+  case "$(nomarmy_execution_mode)" in
+    remote) echo "Profile '$NOMARMY_PROFILE' uses the model server at $NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT; skipping llama.cpp build." ;;
+    hosted) echo "Profile '$NOMARMY_PROFILE' runs every job on an api or subscription agent; skipping llama.cpp build." ;;
+    *) echo "Profile '$NOMARMY_PROFILE' uses hosted inference at ${NOMARMY_BEDROCK_BASE_URL:-Bedrock}; skipping llama.cpp build." ;;
+  esac
+  exit 0
+fi
 SRC="$NOMARMY_INSTALL_ROOT/llama.cpp"; mkdir -p "$NOMARMY_INSTALL_ROOT"
 if [[ ! -d "$SRC/.git" ]]; then git clone --depth 1 https://github.com/ggml-org/llama.cpp.git "$SRC"; else git -C "$SRC" pull --ff-only; fi
 if [[ "$(uname -s)" == Darwin ]]; then

package/scripts/lib.sh

@@ -24,9 +24,33 @@ nomarmy_available_profiles(){
   find "$root/config/profiles" -name '*.env' -exec basename {} .env \; | sort | tr '\n' ' '
 }
 
-# True when the active profile runs inference on a hosted endpoint rather than
-# a local llama-server. Scripts branch on this instead of on the profile name.
-nomarmy_is_cloud(){ [[ "${NOMARMY_EXECUTION:-local}" != "local" ]]; }
+# Where this install's models run (lib/execution.mjs is the same logic for the
+# MCP server). Scripts branch on these instead of on the profile name.
+#   local    a llama-server on this machine, started and sized by nomArmy
+#   remote   a llama-server nomArmy doesn't run, e.g. a team's GPU server or an
+#            SSH tunnel to one (NOMARMY_EXECUTION=remote, or local with a
+#            non-loopback NOMARMY_LLAMA_HOST)
+#   hosted   no local model: every job runs on an api or subscription agent
+#   bedrock  the Bedrock cloud profiles
+nomarmy_is_loopback_host(){
+  local h
+  h="$(printf '%s' "${1:-}" | tr '[:upper:]' '[:lower:]')"
+  [[ -z "$h" || "$h" == localhost || "$h" == ::1 || "$h" == "[::1]" || "$h" == 0.0.0.0 || "$h" == 127.* ]]
+}
+nomarmy_execution_mode(){
+  case "${NOMARMY_EXECUTION:-local}" in
+    hosted) echo hosted ;;
+    bedrock) echo bedrock ;;
+    remote) echo remote ;;
+    *) if nomarmy_is_loopback_host "${NOMARMY_LLAMA_HOST:-127.0.0.1}"; then echo local; else echo remote; fi ;;
+  esac
+}
+# True on the Bedrock profiles: a Bedrock credential, the AWS CLI and a region.
+nomarmy_is_cloud(){ [[ "$(nomarmy_execution_mode)" == bedrock ]]; }
+# True when jobs can run on the `local` agent (a llama-server here or remote).
+nomarmy_has_local_model(){ local m; m="$(nomarmy_execution_mode)"; [[ "$m" == local || "$m" == remote ]]; }
+# True when nomArmy builds, starts, stops and sizes llama-server on this machine.
+nomarmy_manages_model_server(){ [[ "$(nomarmy_execution_mode)" == local ]]; }
 
 nomarmy_validate_cloud(){
   local missing=()
@@ -124,6 +148,9 @@ load_profile(){
     # Cloud profiles host no local model, so they carry no hardware or OS
     # requirement and are the only profiles usable on a machine without a GPU.
     nomarmy_validate_cloud
+  elif ! nomarmy_manages_model_server; then
+    # hosted and remote run no model here either, so any machine will do.
+    :
   else
     if [[ "$os" == Darwin && "$profile" != macbook-pro ]]; then
       echo "ERROR: profile '$profile' requires Linux. Use macbook-pro on macOS." >&2

package/scripts/start-inference.sh

@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; source "$ROOT/scripts/lib.sh"; load_profile "${1:-}"
-if nomarmy_is_cloud; then echo "Profile '$NOMARMY_PROFILE' uses hosted inference at $NOMARMY_BEDROCK_BASE_URL; no local llama-server to start."; exit 0; fi
+if ! nomarmy_manages_model_server; then
+  case "$(nomarmy_execution_mode)" in
+    remote) echo "Profile '$NOMARMY_PROFILE' uses the model server at $NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT; no llama-server to start." ;;
+    hosted) echo "Profile '$NOMARMY_PROFILE' runs every job on an api or subscription agent; no llama-server to start." ;;
+    *) echo "Profile '$NOMARMY_PROFILE' uses hosted inference at ${NOMARMY_BEDROCK_BASE_URL:-Bedrock}; no llama-server to start." ;;
+  esac
+  exit 0
+fi
 mkdir -p "$NOMARMY_INSTALL_ROOT/run" "$NOMARMY_INSTALL_ROOT/logs"
 PID="$NOMARMY_INSTALL_ROOT/run/llama.pid"; LOG="$NOMARMY_INSTALL_ROOT/logs/llama-server.log"
 if [[ -f "$PID" ]] && kill -0 "$(cat "$PID")" 2>/dev/null; then echo "llama-server already running PID $(cat "$PID")"; exit 0; fi

package/scripts/stop-inference.sh

@@ -1,5 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"; source "$ROOT/scripts/lib.sh"; load_profile "${1:-}"
-if nomarmy_is_cloud; then echo "Profile '$NOMARMY_PROFILE' uses hosted inference; nothing local to stop."; exit 0; fi
+if ! nomarmy_manages_model_server; then
+  case "$(nomarmy_execution_mode)" in
+    remote) echo "Profile '$NOMARMY_PROFILE' uses the model server at $NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT; nothing local to stop." ;;
+    hosted) echo "Profile '$NOMARMY_PROFILE' runs every job on an api or subscription agent; nothing local to stop." ;;
+    *) echo "Profile '$NOMARMY_PROFILE' uses hosted inference at ${NOMARMY_BEDROCK_BASE_URL:-Bedrock}; nothing local to stop." ;;
+  esac
+  exit 0
+fi
 PID="$NOMARMY_INSTALL_ROOT/run/llama.pid"; if [[ -f "$PID" ]] && kill -0 "$(cat "$PID")" 2>/dev/null; then kill "$(cat "$PID")"; fi; rm -f "$PID"; echo stopped

package/scripts/verify-install.sh

@@ -24,6 +24,11 @@ if nomarmy_is_cloud; then
       echo "FAIL Bedrock model not listed in $NOMARMY_BEDROCK_REGION: $model"; fail=1
     fi
   done
+elif [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "INFO hosted profile '$NOMARMY_PROFILE': no local model; jobs run on api or subscription agents"
+elif [[ "$(nomarmy_execution_mode)" == remote ]]; then
+  echo "INFO profile '$NOMARMY_PROFILE' uses the model server at $NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT"
+  check curl -fsS --max-time 5 "http://$NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT/health"
 else
   check "$NOMARMY_INSTALL_ROOT/llama-server" --version
   if [[ "$(uname -s)" == Darwin ]]; then
@@ -36,9 +41,13 @@ else
   check curl -fsS "http://$NOMARMY_LLAMA_HOST:$NOMARMY_LLAMA_PORT/health"
 fi
 
-openclaw models list --provider "$NOMARMY_WORKER_PROVIDER" | grep -q "$NOMARMY_WORKER_MODEL" \
-  && echo "PASS OpenClaw worker model ($NOMARMY_WORKER_PROVIDER/$NOMARMY_WORKER_MODEL)" \
-  || { echo "FAIL OpenClaw worker model ($NOMARMY_WORKER_PROVIDER/$NOMARMY_WORKER_MODEL)"; fail=1; }
+if [[ "$(nomarmy_execution_mode)" == hosted ]]; then
+  echo "INFO no worker model to check; nomarmy doctor checks each agent"
+else
+  openclaw models list --provider "$NOMARMY_WORKER_PROVIDER" | grep -q "$NOMARMY_WORKER_MODEL" \
+    && echo "PASS OpenClaw worker model ($NOMARMY_WORKER_PROVIDER/$NOMARMY_WORKER_MODEL)" \
+    || { echo "FAIL OpenClaw worker model ($NOMARMY_WORKER_PROVIDER/$NOMARMY_WORKER_MODEL)"; fail=1; }
+fi
 # The sandbox config keeps its "docker" sub-key namespace regardless of
 # backend, so grepping the whole block for "docker" would falsely pass even
 # when the backend is podman. Check the actual backend value instead.
@@ -46,12 +55,13 @@ SANDBOX_BACKEND="$(openclaw config get agents.defaults.sandbox.backend 2>/dev/nu
 [[ "$SANDBOX_BACKEND" == "podman" ]] && echo 'PASS Podman sandbox configured' || { echo "FAIL Podman sandbox (backend is '$SANDBOX_BACKEND')"; fail=1; }
 
 # The no-network sandbox is what keeps repository content away from any
-# credential the host process holds. It is a hard requirement on cloud profiles.
+# credential the host process holds. It is a hard requirement on cloud and
+# hosted profiles, where every job runs against a real credential.
 SANDBOX_NET="$(openclaw config get agents.defaults.sandbox.docker.network 2>/dev/null | tr -d '[:space:]"' || true)"
 if [[ "$SANDBOX_NET" == "none" ]]; then
   echo 'PASS Sandbox network isolated'
-elif nomarmy_is_cloud; then
-  echo "FAIL Sandbox network is '$SANDBOX_NET', must be 'none' on a cloud profile"; fail=1
+elif ! nomarmy_has_local_model; then
+  echo "FAIL Sandbox network is '$SANDBOX_NET', must be 'none' on a ${NOMARMY_EXECUTION} profile"; fail=1
 else
   echo "WARN Sandbox network is '$SANDBOX_NET', expected 'none'"
 fi