The AI Stack

The previous two chapters were about AI operating FrontierStack: the built-in Administrator (Chapter 13) and driving the app from your own tool over MCP (Chapter 14). This chapter is the reverse. It covers the AI infrastructure FrontierStack helps you run and monitor — agent platforms, local model servers, code sandboxes, browser automation, GPU fabric, ML tooling, governance, and the cost of all of it. These are services in the catalog like any other, grouped under the AI categories in the sidebar, but they deserve a chapter of their own because running AI is now a stack you operate, not a box you call.

15.1The Agent Platforms board

Open Agent Platforms from the sidebar to see every AI agent runtime FrontierStack knows about, on one board with a live status dot per row. The header reads, for example, "3 of 7 running" — how many configured runtimes are reachable and up. A runtime row shows its running state, the model it is serving, and, where the runtime reports them, its agents, tokens and active sessions. The AI tool get_agent_platforms exposes exactly this to the Administrator, so you can ask "which agent runtimes are down?" in plain English.

The runtimes fall into two kinds. Some are CLI runtimes — detected by their command-line tool being installed (and answering --version): the coding agents Claude Code, Gemini CLI, OpenAI Codex and Factory's droid. Others are HTTP runtimes that expose a status endpoint and are polled for live metrics. A handful of cloud agent products (OpenHands, Manus, Devin, OpenAI Operator, E2B) appear lower down as catalog entries you connect rather than poll.

Because configured runtimes feed the broader system, a runtime that goes down — or hits a token quota (rate-limit, 429, billing) — raises an Alert and appears red on the Local Health board, in the services group. You configure each runtime's endpoint and credentials once; from then on it is watched like any other service.

15.2Registry, Task Queue, Model Router & Connectors

Four companion panes break the agent fleet down by concern, all reading the same live runtime state:

• Agent Registry — the master list: every runtime plus the cloud agent products in the catalog, with a "credentials saved" marker for each whose token is in the Keychain. This is where you see, in one place, everything FrontierStack can talk to.
• Task Queue — active agent sessions and runs across your runtimes. Per-invocation CLIs (Claude Code, Gemini, Codex, Factory) appear as "on-demand" since they spin up per task rather than running a daemon.
• Model Router — which model and which API key each runtime uses. It reads each runtime's reported model and the provider key it needs, and shows whether that key is present (edit keys in AI Models). Use it to confirm a runtime is pointed at the model — and the spend — you intend.
• Repository Connectors — the Git providers your agents can read and write. Capture a GitHub, GitLab or Bitbucket personal access token (stored in the Keychain) and FrontierStack runs a live /user reachability check so you know the credential works before an agent needs it.

Agent runtimes and connectors authenticate with credentials you save once. Like everywhere in FrontierStack, those tokens live in the macOS Keychain, never in the app's settings file and never sent to a cloud model.

15.3Agent Sessions & the built-in terminal

Agent Sessions is the manager for goal-driven ops and SaaS loops you build yourself — "one-shot or recurring", as the header says. A session has a goal in plain English, a title, a step budget, and a switch for whether it may make changes. Run it once, or set it recurring (it re-runs when its interval elapses) to watch something on a schedule. Each session drives the same guarded tools as the Administrator (Chapter 13) and streams every step to a transcript you can stop at any time; scripts are never permitted from a session loop. This is the home of agents like "watch this endpoint and restart it if it stalls" or "reconcile inventory every morning."

FrontierStack also embeds a real terminal for when you want a shell beside your agents. The engine is SwiftTerm, running a login zsh in a PTY, and you can restyle it: under Terminal Style you import colour themes from iTerm2 (.itermcolors), Ghostty, or generic Alacritty/Warp key-value files, on top of built-in dark, light and Solarized themes. The terminal is the same engine the agent-loop console uses, so what you see matches what your sessions run against.

15.4Running local models

You do not have to send anything to a cloud model at all. FrontierStack manages local inference servers and can point the Administrator at one of them. The big three local apps are first-class:

• Ollama — the simplest local model runner; pull and serve models, and select one as the Administrator's engine.
• LM Studio — the LM Studio pane detects the install, lists loaded models and what is downloaded via the lms CLI, and shows "N models loaded" or "no model loaded" in its header.
• VibeProxy — the odd one out: not a model runtime but a bridge to the AI subscriptions you already pay for. Connect Claude Code, ChatGPT, Gemini, Kimi, Qwen, GitHub Copilot or Z.AI GLM once, and those models appear in the harness picker without a separate metered API key. The VibeProxy pane installs it with Homebrew, starts and stops it, carries the usual Group Start / Run at startup settings, and opens the CLI Proxy API dashboard for request logs and account status.
• LocalAI — a self-hosted, OpenAI-compatible server you run as a catalog service on port 8080.

Beyond these, the AI / LLMs category carries the whole self-hosted-inference shelf — vLLM, llama.cpp, Apple's MLX-LM server, Jan, LiteLLM (a proxy fronting 100+ providers), Open WebUI, AnythingLLM, PrivateGPT and RAG/vector tooling. The point of running one locally is privacy and cost: when the Administrator's engine is a local model (Ollama, a loopback endpoint, or Apple's on-device model), nothing is redacted because nothing leaves your Mac — the secret-scrubbing that protects cloud engines simply is not needed.

15.5Code sandboxes & browser automation

Agents need somewhere safe to run code and a way to read the live web. FrontierStack manages both.

For code, the E2B pane manages secure cloud sandboxes via the e2b CLI: enter an API key (stored in the Keychain as E2B_API_KEY, or authenticate once with e2b auth login), then list, spawn from a template, and kill running sandboxes — with a Kill All for housekeeping and an "include paused" toggle. A green dot marks running sandboxes; orange marks paused. It is the disposable, isolated machine an agent uses so its code never touches your servers.

For the web, the AI category includes browser and crawl tooling: Browserbase (managed headless browsers), Crawl4AI, Firecrawl and Apify for turning sites into clean, model-ready text, plus Playwright for scripted automation. These give an agent eyes on pages that have no API.

15.6GPU infrastructure & clusters

If your AI runs on real GPUs, the GPU Fabric pane gives you read-only health of the hardware. Pick a linked server and run diagnostics over SSH: GPU inventory and temperature (nvidia-smi), NVLink status, the GPU topology matrix, NVSwitch Fabric Manager health, DCGM inventory (dcgmi), InfiniBand and RoCE/RDMA links, Slurm GPU allocation, and composable-fabric CLIs (WEKA, Liqid, GigaIO). The GPUs live on Linux hosts, so this targets a server in your fleet; on a non-GPU machine the tools simply report "not found". Run one check or Run All Checks at once.

GPU thermals and load on a host are also surfaced through the standard host monitors (Chapter 8) when an agent is installed, so a GPU box that overheats raises an alert like any other machine. For scale-out, the AI Clusters category carries Exo (run one model across several of your Macs), Petals, Distributed Llama, Ray, Slurm and Run:ai; the ML Workbench category carries the experiment-tracking and pipeline tools (MLflow, ClearML, Weights & Biases, Kubeflow, JupyterLab) for the training side of the house.

15.7AI governance & safety

Running agents in production means watching what they do and bounding what they can. FrontierStack catalogs the AI Governance & Safety shelf so these tools sit alongside the runtimes they observe: Langfuse, Helicone and Arize Phoenix for LLM observability and tracing; Promptfoo, Ragas and garak for evals and red-teaming; Guardrails AI, NeMo Guardrails and Lakera Guard for input/output validation and prompt-injection defence; and governance platforms such as Credo AI and Holistic AI. Install and monitor them as catalog services; they are the audit trail and seatbelts for the agents on the boards above.

15.8The AI cost monitor

Running an assistant, your own agents, several local models and outside harnesses means spend in several places. AI Model Costs pulls it into one view. The header shows this month's total and the percentage of budget; a colour-coded bar turns orange at 80% and red at 100%. The AI tool get_ai_costs exposes the same figures to the Administrator.

The dashboard tracks three streams together:

• Metered API spend, per provider and model, computed from an editable price table (USD per million tokens), or entered directly from an invoice. Connect Accounts auto-pulls month-to-date spend from OpenAI, Anthropic, OpenRouter, DeepSeek and a self-hosted LiteLLM proxy — several accounts per provider, each its own cost line.
• Flat subscriptions — ChatGPT Plus, Claude Pro/Max, Cursor, Perplexity, T3 Chat and the like — folded into the month's total and shown as their own slices. Toggle one off to exclude it without deleting it.
• Local CLI usage — a one-click scan of this Mac's Claude Code and Codex logs sums the month's tokens per model as an estimate.

A by-provider breakdown (donut chart), a six-month trend with the budget line, and an Ask AI button that hands your spend to a cost-optimisation advisor round it out. A billing-health watcher probes connected paid services for out-of-credits, hard-limit, past-due or suspended states and raises an alert — catching a key that is about to stop working before it does.