← Back to Blog

Sovereign AI Workstation Best Practices: Keeping Claude and ChatGPT Working

· Updated October 25, 2026 · 39 min read A rack server connected to organized folders, a clock face and a small browser window, with one connection drawn in red.

New to this? Start with Sovereign AI Made Simple.

A useful AI workstation keeps your project, tools, and working context available after the conversation ends. Keeping that workstation useful takes more than leaving a server switched on. The browser must be reachable by the right agent. Desktop applications need a usable credential store. Updates must reach the executable your shortcut actually starts.

Our October 8 to 10 review found progress in all three areas, alongside two unfinished conditions: the owner's persistent default keyring was still missing, and a browser connection that worked on October 9 was unavailable to the next scheduled run. Those findings are more useful than a blanket declaration that the desktop is fixed.

The OVH migration began on October 4. Earlier AWS operations provide additional history, but do not establish three months of OVH operation. This update corrects that distinction and separates observed results from practices you can apply to your own system.

Build your own version: Download the full playbook as Markdown. It includes setup guidance and verification steps you can adapt to a Linux host.

What the October 8 to 10 review established

The change-review window was October 8, 2026 at 04:34:58 UTC through October 10 at 04:34:58 UTC. A separate read-only OVH metadata check at 04:40:04 UTC on October 10 confirmed the current release and remaining keyring condition.

The connected AWS inventory was retained in a follow-up checkpoint collected at 04:40:54 UTC; it compares active versions rather than proving that every installation occurred within the window. All operational times below are UTC.

Scroll to compare columns and rows when the table extends beyond the box.

Area Recorded result What remains to prove
OVH Webtop Release r20261009T122500Z remained active; Claude Desktop 2.31226.0; four intended desktop launchers Continued task success after subsequent sessions and restarts
Keyring repair 17 staging checks and 16 production checks passed; synthetic secret survived daemon and session-bus restart Owner setup and retained owner sign-in; the live helper still reported persistent_default_missing
Browser work October 9 run used verified Linux Chrome; one indexing request accepted, one refused October 10 run reported browser_missing, with zero accepted and zero refused
Fetch/render proxies Five endpoints passed health, unauthorized-access, and authenticated-content checks from the OVH workflow LLM inference, streaming, and unrelated ChatGPT web integrations were outside those checks
AWS follow-up inventory Claude Code 2.1.296 and Codex 0.162.0 active Desktop, Node, and PowerShell updates had differing staged or active states

These are point-in-time observations. A previous successful receipt remains useful evidence, but a later failure changes the current operating status.

Put durable state under your control

The practical benefit of a dedicated workstation is continuity. Repositories remain checked out. Project notes survive. A browser profile can retain its settings and authorized sessions. Scheduled work has a place to write results that the next session can inspect.

Decide which of those things must survive before choosing the desktop image or model provider. In a container, explicitly persist the required directories; the fact that the container runs on hardware you rent does not preserve its writable layer when you replace it.

Hosting the workspace also does not make every model request local. A local model may run on your own CPU or GPU; a hosted model still processes requests through its provider. Your storage, execution, and inference choices can be independent. The Sovereign Advantage comparison develops that distinction.

Keep the cost boundary equally clear. The machine, backups, model usage, and any remote rendering or proxy services can have separate costs. OpenAI's authentication documentation distinguishes ChatGPT sign-in from API-key billing.

Claude's gateway guidance explains that adding a gateway credential can change which account pays for inference; changing only the base URL does not automatically replace a saved subscription identity. A provider selector should make that choice understandable before a task starts.

Rebuild the desktop while preserving its home

The October 9 repair was incorporated into the managed image and startup files, staged, and promoted through an actual container recreation. That is stronger evidence of persistence than installing a package inside a running container and checking that it launches once.

LinuxServer documents /config as the desktop user's home, including browser profiles and application settings. Its normal update workflow replaces the image and recreates the container. Packages and changes outside persisted storage need a reproducible installation path.

Use the image recipe for the operating-system packages your desktop depends on. Use persistent user storage for settings and appropriate user-installed tools. For smaller customizations, LinuxServer supports startup scripts and supervised services; those hooks need their own declared mounts.

Its customization guide recommends a custom image for repeated package requirements or changes to session startup.

The repair also changed our assessment of staging. The earlier version of this article dismissed a second desktop container too broadly. Here, a separate profile and synthetic keyring let the checks exercise credential persistence and application startup without using the owner's secrets. That staging environment earned its place.

A useful promotion record identifies the image, records the checks, preserves the previous image and profile backup, and says what the checks did not cover. The October 9 release still had a 24-hour probation period scheduled to end at 12:36:39 on October 10. Our review ended before that time; passing early probes was not evidence that the entire observation period had finished.

Give the desktop container a fixed hostname as well. Chromium based browsers record the hostname in their profile lock, and a container recreated with a new hostname stops at a "profile in use on another computer" prompt. The mobile workspace lessons explain this and the other phone desktop fixes.

Check the real runtime, not just its directory

One October 9 browser repair began with a misleading directory listing. An older Chrome version directory still existed, but its executable was gone. The resolver now checks installed executables and skips incomplete entries. Thirteen resolver and wrapper tests passed, followed by six browser diagnostics in a disposable container with Chrome’s sandbox enabled.

That fixture proved the selected runtime could render its fixed public pages and return the expected content. It did not prove that every protected website would admit automation. A separate QA directory on the same host had its own browser version and dependencies; a successful check of one installation did not validate the other.

Display problems required the same precision. The October 8 session record showed mobile access shrinking the desktop to 440 × 536 while XFCE was already running. The later manual resolution and Chrome autostart configuration survived recreation.

These were useful repairs, but the October 10 discovery failure shows that a visible browser window and a working agent connection still require separate checks.

A saved profile still needs a usable keyring

The keyring problem was more specific than a missing package. GNOME Keyring and Secret Service were available, but the owner's session had only a temporary collection and no persistent default keyring. Initial creation had been cancelled. An application could appear signed in while still being unable to save that sign-in for later.

The repair added a managed helper and launcher checks. Its synthetic test created a secret, confirmed encrypted on-disk storage, restarted the keyring daemon and session bus, and verified that the secret survived. It also verified that a locked collection rejected reads. The test used an isolated profile and no owner credentials.

That proves the tested mechanism. The live owner check on October 9, confirmed again in the October 10 follow-up, still returned not ready: persistent_default_missing, with no persistent keyring files. Retained owner sign-in was therefore unverified. The next step remained ordinary private keyring setup, followed by application sign-in and a full quit-and-reopen check.

Claude's Linux documentation specifically requires a reachable desktop keyring that is not locked to retain sign-in.

The Secret Service specification places that service in the user's login session; its rules for locked collections require applications to handle secrets becoming locked again.

For your own desktop, record separate results for app relaunch, desktop logout/login, container recreation, and host reboot. Credentials may remain safely stored while requiring the owner to provide its password in a new session. A claim of unattended recovery needs evidence that every required dependency becomes usable again.

Do not hide the warning by selecting basic password storage. Electron documents that its Linux basic_text fallback lacks meaningful secret protection. The useful fix is an appropriate secret store, correct session access, and an honest account of when the owner must provide the keyring password.

Test the shortcut the owner actually clicks

The desktop was reduced to four intended launchers: Provider Selection, Claude Code, ChatGPT Quick Start, and Chrome with AI Extensions. The recorded visual review found distinct icons, and the later release retained the four entries. That gives the owner a clearer starting point.

Each entry still has a different contract. The provider selector opens an authenticated application. Claude Code starts a CLI session. The ChatGPT quick start opens the configured Codex workflow; the name does not establish a new ChatGPT web connector. Chrome opens the browser with its extensions, whose account connection must be checked separately.

Use the desktop launch path for acceptance checks. A command working over SSH does not establish the same PATH, working directory, session bus, or browser environment as a desktop click.

The Desktop Entry Specification defines Exec, TryExec, Path, and Terminal; its execution rules explain how the desktop resolves the executable.

Give your wrappers stable names and keep initialization there. Avoid taking over the vendor executable's name just to add a shortcut. Claude's updater documentation explains that a custom native launcher can remain in place while newer versions install elsewhere. An updater can succeed while a wrapper continues selecting an older binary.

Check the launched version and use claude doctor when the installation path is unclear.

Read the active version after an update

The connected AWS server supplied a useful comparison. Its live inventory showed Claude Code 2.1.296 and Codex 0.162.0. Other entries had not reached the same completion state:

Scroll to compare columns and rows when the table extends beyond the box.

AWS component Observed active version Update evidence
Claude Desktop 1.40609.0.0 A deferred 2.31226.0.0 update had been accepted; the active application was still older
Node.js 24.15.0 The 24.21.0 installer was staged
PowerShell 7.6.5.0 The 7.6.6 target was not installed

Downloading an installer, accepting a deferred update, installing a package, and starting the new executable are different milestones. Keep them distinct in the handoff. A later session should be able to tell whether it needs to install, restart, or simply verify.

Match the update procedure to the detected installation. Native Claude Code, package-manager Claude Code, Linux Claude Desktop, and Codex can have different update paths. The current Codex CLI guide documents its supported installation workflow.

A newer version on another machine is a reason to inspect the channel and target, not proof that a stable-channel check failed.

Also run verification as the actual desktop user. In this review, root-owned Codex temporary objects caused warnings for the ordinary account. The repair corrected the affected ownership and changed subsequent probes to run as the desktop user. Root-level maintenance should not quietly leave user workflows dependent on root-owned temporary files.

Give background work a supervisor and a clear result

Long-running user tasks belong under a service manager rather than in a terminal someone hopes will stay open. On a systemd host, these commands provide a useful first inventory:

systemctl --user list-unit-files --state=enabled
systemctl --user list-timers
systemctl --user --failed

Where the user manager must start at boot and survive logout, configure lingering for the intended service account. The systemd loginctl manual describes that behavior. Lingering does not itself create a graphical session, connect an extension, or make a locked keyring available.

Running a service as an ordinary user limits its privileges to that account and its granted capabilities. It does not make the account's files inaccessible to root or guarantee that a mistake cannot affect the host. Choose user units for user-owned work; use appropriately configured system services where the task requires them.

Filesystem permissions and any process or container isolation still matter.

Keep a small supervisor outside the agent process. A watchdog can detect that an agent died, but it should also know when to stop restarting: a broken credential store or repeated provider failure will not improve through an endless retry loop. The recent desktop promotion combined probes with a probation record and a failure threshold. The principle is bounded recovery with visible evidence.

Keep permission modes and tool scope explicit

One difference between two otherwise similar sessions was who could answer a permission request. An interactive session had an owner present; an unattended launcher used automatic review. The launch arguments and approval path belong in the diagnosis before blaming the operating system or model.

Claude's permission-mode guide distinguishes Manual mode, whose configuration value is default, from auto, which uses background checks. dontAsk denies actions that would need a prompt. Defaults and details change with versions, so inspect the installed client and effective launch configuration.

This also corrects an earlier example here: --allowedTools is an auto-approval list, not a complete list of available tools or an operating-system sandbox. The CLI reference distinguishes it from --tools, which restricts built-in tool availability; MCP tools require separate configuration or restrictions.

A narrow wrapper remains a useful pattern. For example, a job can be permitted to call a reviewed status-recording command instead of receiving general permission to run an interpreter. Review the wrapper's accepted arguments as well as its name. Then combine the intended tools, approval rules, service account, and filesystem access to fit the job.

A denied action should produce a reason and a defined recovery step. Do not turn a global permission bypass into the standard fix for a missing approval, a browser connection failure, or a protected operation. Those are different conditions with different remedies.

Verify the browser at the start of each run

The browser record contains both a recovery and a regression. On October 9, the scheduled indexing workflow verified Linux Chrome and used its own tab. It recorded an accepted request at 05:34:06, followed by a quota refusal and one same-page retry, then stopped at 05:39:39. A separate example-page walkthrough also verified Linux browser control later that morning.

On October 10 at 04:00:44, the next recorded run reported browser_missing. Both discovery attempts found no browser. It recorded zero accepted and zero refused. The previous day's page walkthrough therefore did not establish durable connectivity. The evidence does not identify the cause of this later disconnection.

An installed extension, a pinned toolbar icon, an authorized account, and a browser exposed to the current agent are separate states. Check the browser's platform and intended session before using it. A connected Windows browser does not satisfy a task explicitly assigned to the Linux desktop. Use a harmless page check in a new tab to establish page access before starting work with side effects.

Search Console illustrates why that dependency matters. Google's Indexing API is limited to eligible job-posting and livestream pages. The URL Inspection API reports index status; it does not expose the console's Request Indexing action.

Ordinary pages therefore cannot substitute those APIs for that particular button.

An accepted indexing request also does not prove that Google indexed the page. Record submission and indexing status separately. Prefer a supported API when it performs the required task, and treat unavoidable browser work as a dependency that can need owner attention.

Make every run report, including one that does nothing

A status file lets the next session distinguish an empty workload from a failed prerequisite. This sanitized representation captures the October 10 result:

{
  "date": "2026-10-10",
  "state": "browser_missing",
  "accepted": 0,
  "refused": 0,
  "reported_at": "2026-10-10T04:00:44Z",
  "summary": "Both browser discovery attempts returned no browser."
}

Use a run identifier and freshness check so yesterday's file cannot satisfy today's completion condition. If the process exits without its expected report, record that as a runner failure. A zero exit code alone does not demonstrate that the intended work happened.

Keep the quota ledger separate from the service status. October 9's accepted request remains part of the history even though October 10 could not connect. A failed run does not reset the provider's quota, prove unused capacity, or account for activity outside this runner. The early quota refusal on October 9 was observed; its underlying cause was not established.

That distinction improves recovery. The next run can resume under the existing limits without inventing a fresh allowance or repeating work merely because the preceding service failed.

Verify fetch proxies at the layer they serve

The October 9 receipts checked five fetch/render proxy endpoints using Cloudflare Workers and Deno paths. Each returned 200 for health, rejected an unauthenticated request with 401, and returned 200 with the expected example content on an authenticated request. Host and desktop MCP access were exercised, with the available actions covering status, fetch, and render.

Those checks establish useful retrieval access from the tested workflows. They made no model requests. They therefore do not establish Claude or OpenAI inference routing, streaming compatibility, provider billing behavior, or a new ChatGPT web connector. Existing application sessions may also need to reload before newly configured tools appear.

If your proxy additionally routes model requests, give that capability its own acceptance test. Claude's gateway compatibility guide specifies API formats, required header handling, and complete streaming event delivery. A healthy endpoint can still buffer a stream, alter an error body, or omit a capability required by the client.

Test from the actual consuming surface with the intended authentication. A provider page returning a login redirect or an unauthenticated API returning 401 can be its expected access gate; those responses alone do not prove a missing route. Confirm the authorized path and expected content before recording functional success.

Preserve recovery evidence and the decisions behind it

The migration review recovered missing proxy source files and verified matching hashes in an operations copy. It did not recover the original Git history. Describe that accurately: recovered source can make future maintenance possible while still lacking the earlier provenance and change sequence.

Apply the same care to backups. Schedule the backup and separately verify that a representative restore works. Preserve the image reference, configuration, and user state needed to return to a known release; a successful archive command is only one part of that proof. Choose the verification interval according to how much lost work you can tolerate.

Two earlier lessons still apply. First, derive repeated configuration from one declared source: our earlier cache-version incident involved a changed constant and stale copies elsewhere. Second, exercise populated data paths. A previous build check passed against empty data while a production loop failed with an unexpected return shape.

Use a small representative fixture and confirm that the relevant failure is detectable.

Keep concise Markdown memory alongside the work: why a decision was made, which attempt failed, the last verified state, and what remains pending. Preserve a superseded observation as history and point to the newer result. The October 9 browser success and October 10 failure both belong in that record; deleting either would make the system harder to understand.

The next useful proof is concrete: complete the owner's private keyring setup, demonstrate retained sign-in, and establish browser access again from the intended session. Then observe the next scheduled run. That is how an available desktop becomes a dependable working environment.

Maintenance that preserves a working machine

Pin the active versions before changing them, back up the state, and update a TEST copy before the live desktop. Change one component at a time, check application health and the actual active version, and retain a tested rollback path. Skip the live desktop while someone is using it. Bound candidate retries: repeated image builds can consume the disk.

Clean up after the update finishes and preserve every image and backup referenced by the rollback pins.

Never launch operating-system package upgrades from a service that may be stopped or killed during installation. An interrupted upgrade can leave the boot image incomplete.

Before any reboot after an interruption, check package-database consistency, complete or repair interrupted package configuration, and verify that the intended kernel has a complete boot image using the distribution's supported tools. A running desktop does not establish that the next boot will work.

A maintenance task waiting for no agent jobs must not count its own waiting agent as active work. Put that wait in a plain shell loop outside the agent queue, with a timeout and a clear failure result. When a launcher hands work to a background service, its exit only confirms the handoff. Require the service's terminal result and the promised artifact before marking the work complete.

Keep secrets out of source files, briefs and logs. Load required credentials into the process environment from the protected credential store, restrict inherited access, and scan every proposed commit. The operator workflow covers job ownership, retrieval coverage and shareable reports.

Check every update candidate before it lands. A poisoned release can come from the real publisher: LiteLLM 1.107.0 did on October 21, 2026, through the project's own pipeline and its floating image tags. Our update command now checks candidates against an IOC list and OSV.dev malicious-package records, holds new Python startup hooks and releases younger than a day, and refuses to patch while anything running matches an indicator. What we checked, and how this setup would recover if a bad release got through.

Verify message dispatch and the populated desktop

A maintenance command sent by email or private chat needs an allowlisted sender, trusted DMARC/DKIM results for email and a fixed dispatcher rather than a shell built from message text. Forced-command SSH and a sandbox or fixed tool set constrain the route. Never use skip-permissions to make an unattended job succeed.

Keep channel credentials with the owner and workflows inactive until configured and tested.

A candidate must pass with an isolated copy of the live profile, including numeric ownership and runtime UIDs. Validate generated health-check quoting before promotion. Close the browser gracefully, snapshot the stopped profile, cap promotion attempts and verify the identical proved image after start and after a second restart, with automatic image/configuration/profile rollback.

An owner-authorized forced interruption keeps those gates intact.

The full chat, email and desktop update pattern defines the sequence and measured limits. The operator kit supplies its checklist.

Run parallel agent jobs with narrow permissions

Between October 12 and 13 the workstation ran content, design, research and publishing work as several unattended coding agent jobs at once. These are the practices that kept that from turning into a cleanup job.

One job per independent target. Give each site, repository or research target its own job, its own folders and its own result file. Chain only real dependencies: the launcher writes queued, started and exited lines to a shared progress file, and a dependent job's launcher waits for its prerequisite's exit line. Five jobs running together used about 2 percent of a 48 core server.

The limits were the hosted model's response time and how politely each website could be asked for pages, not CPU. On a machine like that, another job is usually affordable; more requests to the same website are not.

Give each job the narrowest permission profile that fits. A blanket permission bypass makes every job as powerful as the most trusted one. Profiles by role work better:

Scroll to compare columns and rows when the table extends beyond the box.

Job role What it may do
Research Fetch public pages and write inside its own folder
Build Research permissions plus local commits in its own working copy
Preview Build permissions plus preview deploys
Shipping, one per site Preview permissions plus the production deploy and the push
Every role Denied outright: force push, account changes, DNS changes, environment variable changes

Claude Code evaluates "deny, then ask, then allow," so a broad allow rule cannot quietly undo a deny. In auto mode the safety classifier still reviews anything that no rule covers. That review is a second line, not a reason to widen the list.

Amend a queued brief; restart a running job. A queued job reads its brief when it starts, so a waiting job's brief can be corrected safely. A running unattended job does not read new messages. To change its course, stop it, amend the brief and relaunch it, and tell the new run to read the notes the stopped run left behind.

Stop work that an upcoming change will invalidate. Measuring a design that is about to be replaced wastes the measurement. Stop and requeue that job. Sequence content, design, compliance, findability and audit passes in that order so each one measures the final thing.

Watch the log file, not the process list. A job is alive if its log keeps changing. Process listings show a process that may be waiting forever, and pattern matches can find the wrong process. Alert only when the state changes. When you stop a job on purpose, write its exit record too, or the watchdog will report it as stalled.

Name the allowed method in a research brief. Research jobs quit early when a capability they need is not explicitly allowed, for example a passive browser render that needs a particular sandbox setting on that host. Write the exact permitted retrieval method into the brief. Ask each job to list the requests only a signed-in browser can serve, so a person can fulfil them in one session.

The Desktop Commander and browser agents guide covers that signed-in browser work.

Three shell traps cost real time when launching jobs on a remote machine. A background launch chained after && puts the whole chain in the background and keeps the remote session open. Killing a process by a pattern that also appears in your own remote command kills that command. Quotes inside a quoted remote command, and heredocs sent the same way, silently corrupt scripts.

Write the script as a file locally, copy it over, then run the file. The operator kit has a launcher and watchdog built around these rules.

Run a prompt hub and phone alerts safely

A prompt hub gives Claude Code, ChatGPT through Codex and the local models one private link, and ntfy sends job results and failures to a phone. Build your own AI prompt hub describes ours. Five practices carry most of the weight.

Plan before run. A link such as ?q=...&target=...&mode=ask should only build a plan: which engine, which machine, which mode and which notes it will attach. Execution waits for a Run button or Enter in the terminal, and a GET request never runs anything, so a link preview, a browser prefetch or a stale bookmark cannot start work. Keep ask mode read-only. Run work mode in Claude Code's auto permission mode inside a folder made for that job, and never pass --dangerously-skip-permissions; the permission-mode guide lists bypass mode for "Isolated containers and VMs only". Deploys, pushes and email get their own confirmation.

Use subscriptions through their own CLIs. Claude Pro or Max and the ChatGPT plans work through the signed-in claude and codex commands. A gateway such as LiteLLM handles API keys, not subscription sign-ins, so the hub calls claude -p and codex exec - rather than sending subscription work through the gateway. It is the billing boundary described near the top of this guide.

Put Claude first, with a real capacity signal. Do not guess when a subscription is used up. In our build, Claude Code's stream-json output carried a rate_limit_event with a status, the window type (for example five_hour) and a reset time. The hub cools Claude down until that reset, shows the window on its status panel and sends the next request to Codex. Local models take triage and short drafts only; a short Hermes 3 answer took about 12 seconds on this CPU-only server.

Keep prompts and customer data out of push messages. An alert carries a job number, a status and a link to a page behind your own sign-in. The public ntfy.sh server caches messages for 12 hours by default, and its privacy policy describes TLS for connections but no end-to-end encryption, so treat every push as readable by the service. Pick an unguessable topic, or self-host with auth-default-access: deny-all.

Verify the Access token yourself. When cloudflared runs on the same machine, every request reaches the hub from loopback, so the source address proves nothing. Check the Cf-Access-Jwt-Assertion token's signature against your team's public keys, its issuer and audience, then an email allowlist, as Cloudflare's validation guide recommends. Pair it with a one-time run token returned only with the plan, JSON-only POST bodies and no CORS headers.

The operator kit has the hub's acceptance table and an alert script. The prompt hub kit and the ntfy alerts cookbook go further.

Secure the Ubuntu host before exposing the workspace

A public AI workstation holds signed-in browsers, project files and model APIs. A remote desktop login can become access to all three. Use a supported Ubuntu LTS, a tested recovery route and a small list of reachable services. These are recommended controls, not a description of any existing server.

The OVHcloud dedicated-server guide is Ubuntu-based general guidance: update packages, consider another SSH port, use restricted users, configure the host firewall, install Fail2ban, configure the provider firewall and back up. The OS controls apply to other dedicated servers and VPSs.

OVH's control panel, Edge Network Firewall, IPMI console and backup products are provider-specific examples. Elsewhere, use the provider's firewall or security groups, remote console, recovery image and independent backup destination.

Start with recovery and security updates

Confirm that you can open the provider console before changing access. On OVH, IPMI supplies console access and rescue mode boots a separate recovery environment. Rescue requires a restart: stop jobs, preserve state and plan downtime before using it.

Do not reinstall, format or repair mounted filesystems as an access-recovery shortcut.

Ubuntu's release table lists 26.04 LTS as current on October 13, 2026; 24.04 LTS remains supported. Check the installed image with cat /etc/os-release. A supported release does not prove that the host is patched. Refresh the index, review the upgrade, then apply it during an agreed maintenance window:

sudo apt update
sudo apt --simulate upgrade
read -r -p 'Reviewed package changes and recovery access? Type APPLY: ' update_ok
if [ "$update_ok" = APPLY ]; then
  sudo apt upgrade
fi
apt list --upgradable
if [ -f /var/run/reboot-required ]; then
  printf '%s\n' 'Plan a reboot after saving jobs and checking recovery access.'
fi

Also check automatic security updates. Install unattended-upgrades if absent. In /etc/apt/apt.conf.d/20auto-upgrades, set APT::Periodic::Update-Package-Lists "1"; and APT::Periodic::Unattended-Upgrade "1";. Review allowed origins in 50unattended-upgrades; third-party repositories are not included automatically.

Keep Unattended-Upgrade::Automatic-Reboot "false"; unless you have designed and tested scheduled reboots. Verify with sudo unattended-upgrade --dry-run --debug, systemctl list-timers apt-daily.timer apt-daily-upgrade.timer and the logs in /var/log/unattended-upgrades. Package updates may restart services even without rebooting, so keep job checkpoints and check service health afterward.

Separate the administrator from agent jobs

Ubuntu user management uses sudo for administration. Run agents and desktop applications under a standard account without sudo or membership in privileged container-management groups. Keep a separate administrator account for reviewed system changes. Creating a new administrator is optional if a tested one already exists:

read -r -p 'New administrator account name: ' admin_account
if [ -n "$admin_account" ]; then
  sudo adduser "$admin_account" && sudo usermod -aG sudo "$admin_account"
fi
read -r -p 'New unprivileged agent account name: ' agent_account
if [ -n "$agent_account" ]; then
  sudo adduser "$agent_account"
  id "$agent_account"
fi

From a new login as the administrator, verify sudo -v. For the agent account, verify id and have the administrator review sudo -l -U "$agent_account". Do not remove the original working access until its replacement passes. A separate account limits accidental privilege use; it does not sandbox every file or network request.

Test key login before disabling SSH passwords

Use Ubuntu's OpenSSH instructions to create a passphrase-protected key with ssh-keygen -t ed25519 on your client. Copy only its public key with ssh-copy-id "$SSH_TARGET", where SSH_TARGET is your private account-and-server destination. Verify the server's host-key fingerprint through a trusted console.

Test a fresh connection with ssh -o PreferredAuthentications=publickey -o PasswordAuthentication=no "$SSH_TARGET". Keep a second authenticated SSH session open and console access ready throughout changes.

For an installation intended to accept keys only, edit a reviewed snippet with sudoedit /etc/ssh/sshd_config.d/00-workstation-access.conf:

PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
KbdInteractiveAuthentication no

Disabling keyboard-interactive authentication also disables some PAM-based second factors. If you use one, design that policy separately. Ubuntu includes snippets early; OpenSSH takes the first value for most settings. Inspect existing snippets and any Match rules, then check sudo sshd -t and sudo sshd -T.

Use sshd -T -C with your real connection parameters to inspect a matching connection policy. Only after a successful key login and syntax test should you apply the change:

sudo sshd -t && {
  read -r -p 'Fresh key login passed, second session open, console ready? Type APPLY: ' ssh_ok
  if [ "$ssh_ok" = APPLY ]; then
    sudo systemctl restart ssh.service
  fi
}

Test another fresh login before closing either recovery session. If it fails, restore the reviewed previous configuration from the still-open session or console, validate it and restart again.

An alternate SSH port is optional

OVH recommends changing port 22 to reduce automated attempts. This may reduce log noise; it does not replace keys or firewall rules. Leaving 22 with those controls is a reasonable choice. If changing it, choose an unused port, check sudo ss -lntp, and allow both old and new ports in the host and provider firewalls first.

Do not copy the guide's edit to the packaged socket unit. Ubuntu's socket-activation note describes the change starting in 22.10 and the configuration generator introduced in 24.04. Inspect systemctl is-active ssh.socket, systemctl cat ssh.socket and your installed OpenSSH documentation.

For a socket-active host, an explicit administrator override made with sudo systemctl edit ssh.socket can retain both listeners during migration:

[Socket]
ListenStream=
ListenStream=22
ListenStream=49152

Here 49152 is an example, not a required port. The empty assignment clears inherited listeners according to systemd's socket manual. Review the resulting unit and bind addresses. Set matching Port 22 and Port 49152 entries in the reviewed SSH configuration.

With syntax passing and console access ready, run sudo systemctl daemon-reload, then sudo systemctl restart ssh.socket ssh.service during the maintenance window. On a service-only installation, restart ssh.service after validation instead. These are access-changing operations: do not run them without the second session and firewall allowances.

Verify the actual listeners with sudo ss -lntp, then run ssh -p 49152 "$SSH_TARGET" from a separate client connection. Update Fail2ban's port list. Only after success should you remove the old listener and old firewall allowances as a separate reviewed change. A correct sshd -T alone does not prove that a socket listens on the intended port.

Filter the host and the provider edge

OVH discusses iptables; Ubuntu documents ufw as its standard host-firewall frontend. Review existing rules first. Do not layer ufw over an independently managed firewall without reconciling ownership. Allow the actual SSH port before enabling it; the OpenSSH profile may still describe port 22 after a port change.

sudo ufw status numbered
read -r -p 'Verified SSH listening port: ' ssh_port
if [[ "$ssh_port" =~ ^[0-9]+$ ]] && (( ssh_port >= 1 && ssh_port <= 65535 )); then
  sudo ufw --dry-run allow "$ssh_port/tcp"
  read -r -p 'Rules reviewed, second SSH session open, console ready? Type APPLY: ' fw_ok
  if [ "$fw_ok" = APPLY ]; then
    sudo ufw allow "$ssh_port/tcp" &&
      sudo ufw default deny incoming &&
      sudo ufw default allow outgoing &&
      sudo ufw enable
  fi
fi
sudo ufw status verbose

During a port migration allow both ports. Add only required public services; a private workstation does not need public model or desktop ports. Check IPv6 rules as well as IPv4, then test a fresh SSH connection from outside the server. If you use source restrictions, account for changing mobile addresses or connect through a VPN.

For OVH, configure the Edge Network Firewall per public IPv4 in the control panel. It is stateless, limited to 20 rules per IP and filters traffic from outside OVH's network. It neither protects IPv6 nor replaces the host firewall.

Order necessary allowances for established TCP, administration, ICMP and any required DNS responses before the final refusal. Leave source ports unrestricted for ordinary client connections, and avoid broad destination-port ranges. Test SSH, DNS, updates and any VPN after the change.

Rules can activate during DDoS mitigation even when the edge firewall was disabled; review them after service changes. On another provider, verify the scope and statefulness of its firewall or security groups instead of copying OVH rules.

Use Fail2ban for repeated login failures

Fail2ban reacts to matching log events by banning sources. It helps with repeated authentication failures, not every intrusion or a volumetric DDoS attack. Install with sudo apt install fail2ban.

Rather than copying the whole distribution jail file, add a small override with sudoedit /etc/fail2ban/jail.d/workstation.local, following the upstream jail configuration:

[sshd]
enabled = true
backend = systemd
port = 22
maxretry = 3
findtime = 5m
bantime = 30m

Use your actual SSH port or both ports during migration. The systemd backend reads the journal; do not add a file logpath to that backend. Enable only jails for services that actually run, and ensure the journal contains their failed authentication events. A mistaken filter can ban your administrator, so have console access ready and review any trusted-source exceptions carefully.

sudo fail2ban-client -t && {
  read -r -p 'Jail, journal and access-recovery checks passed? Type APPLY: ' ban_ok
  if [ "$ban_ok" = APPLY ]; then
    sudo systemctl restart fail2ban
  fi
}
sudo fail2ban-client status sshd
sudo journalctl -u ssh.service --since '1 hour ago'

Use the client manual to inspect the active jail and counters. Test failures only from a disposable second client with console access, never by deliberately banning your sole access route. Installation alone is not evidence of an active jail.

Keep desktop and model ports private

Ollama binds its model API to loopback port 11434 by default. Preserve that boundary. A browser desktop, dashboard or gateway should similarly bind to loopback or a deliberately restricted private interface. This keeps signed-in sessions and compute capacity away from unsolicited Internet traffic.

For a native Ollama systemd service, sudo systemctl edit ollama.service can set the following IPv6 loopback example. Confirm IPv6 loopback is enabled before choosing it:

[Service]
Environment="OLLAMA_HOST=[::1]:11434"

Save jobs and review the service before running sudo systemctl daemon-reload and sudo systemctl restart ollama.service. Verify sudo ss -lntp and curl --fail 'http://[::1]:11434/api/tags'. For containers, binding inside the container to all interfaces can be needed for private container-to-container traffic. Restrict the host publication separately.

A Docker Compose port such as "[::1]:8080:8080" publishes the dashboard only on the host's IPv6 loopback. Substitute the actual desktop or gateway port. Recreate only the intended service after reviewing the Compose change and saving desktop work.

Docker warns that published ports bypass ufw. Do not treat a ufw deny as proof that a container API is private. Inspect docker ps, docker inspect and host listeners, then test from a separate external machine over IPv4 and IPv6.

Docker also documents a same-network reachability caveat for loopback-published ports on releases older than 28.0.0; use a supported fixed release and verify the network boundary.

Reach the private service using OpenSSH local forwarding, or a reviewed VPN with a restricted peer policy. From the client, after defining your private SSH destination:

: "${SSH_TARGET:?Set your private SSH destination}"
ssh -N -o ExitOnForwardFailure=yes \
  -L '[::1]:8080:[::1]:8080' \
  -L '[::1]:11434:[::1]:11434' "$SSH_TARGET"

Add -p with your verified alternate SSH port if needed. Open the dashboard at http://[::1]:8080 on that client. The destination bind must match the server service. Verify the tunnel works and direct public access to the service fails. A tunnel is private transport, not application authorization; retain application login and narrow agent permissions.

Back up the state, then test recovery

OVH's guide delegates backups to its Veeam Enterprise overview. That is a separately provisioned product, not a built-in guarantee that your server is backed up. Another provider's backup storage or an independent encrypted repository can serve the same purpose.

Back up project data, service configuration, persistent volumes and necessary recovery secrets under restricted access. Pause writers or use application-consistent database backups; a copied live volume may not restore cleanly. RAID and a snapshot on the same host do not supply an independent recovery copy.

For an existing Restic backup, list snapshots and restore to a new empty test destination, following the Restic restore guide:

# Supply repository and credentials through protected configuration first.
restic snapshots
read -r -p 'New empty absolute restore-test directory: ' restore_test
if [[ "$restore_test" = /* ]] && [ ! -e "$restore_test" ]; then
  read -r -p 'Confirmed isolated test destination? Type RESTORE: ' restore_ok
  if [ "$restore_ok" = RESTORE ]; then
    mkdir -m 700 -- "$restore_test" &&
      restic restore latest --target "$restore_test"
  fi
fi

Choose the snapshot deliberately if latest is not the intended recovery point. Check restored files, configuration and a harmless application workflow in isolation before recording success. Never restore over the live desktop or disclose backup credentials in a report. Keep a private recovery checklist and run a restore drill after major configuration changes.

Measure capacity before raising concurrency

A quiet server needs a queue of independent work before it needs new kernel settings. In an October 13 review, a CPU-only machine had 48 logical CPUs on 24 physical cores, two NUMA nodes and about 75 GiB available. The model server already allowed four simultaneous requests and had a 48 GiB memory ceiling. No model was loaded before the test. Raising that ceiling would not have created work.

I use this starting budget for that size of machine. These are admission recommendations, not measured maximum capacities. The categories share the same headroom; they cannot all consume their maximum without another check.

Scroll to compare columns and rows when the table extends beyond the box.

Work Initial budget Admission check
Hosted-model agent jobs 8 independent jobs One writer per target; provider quotas still apply
Independent browser processes 4 separate browser processes No shared signed-in profile; pace requests per origin
Builds 2 builds, up to 8 workers each Reduce alongside sustained local inference
Local small-model requests 4 with 2,048-token context Measure latency, quality and memory at this context
Local 8B requests Start with 2 This is a recommendation awaiting its own benchmark

Pause new admissions when one-minute load reaches half the logical CPU count or available memory falls to 20 GiB. Check load and memory again after each batch. Load average is a coarse indicator of runnable and blocked work, not CPU utilization. A capacity display is a hint, not an atomic reservation: serialize the scheduler's admission decision.

Increase the eight-job budget only after representative work shows headroom and no remote quota failures.

The real host limit was file notification instances. A short probe could open only 14 additional inotify instances under a per-user limit of 128. Raising that limit to 1,024 let the same probe open all 256 requested instances. Each descriptor was closed after the test. Existing service health checks still passed without a restart.

The watch-count limit was already ample; raising both limits blindly would have hidden the distinction.

Inspect fs.inotify.max_user_instances, fs.inotify.max_user_watches and ulimit -Sn before changing them. Linux reports EMFILE for an exhausted instance limit as well as a process descriptor limit, so verify both. Back up the selected sysctl drop-in, change one setting, apply that file only, repeat the probe and check real service requests.

Retain the previous value for runtime rollback and restore the previous file for reboot rollback. Do not weaken browser sandboxing or container isolation to obtain concurrency.

Docker CPU quotas and memory ceilings are limits, not reservations. Idle dashboards, gateways and automation services did not justify extra workers in this review. Swappiness had no practical effect because the host had no swap. Keep the governor, dirty-page policy and TCP settings until a representative before-and-after test supports a change.

A negotiated NIC speed is not the provider's external bandwidth allowance. For a provisioned 1 Gbps link, the nominal ceiling is 125 MB/s before overhead, shared with backups and other transfers. I did not certify network throughput during an active backup.

Fix the Drive client before throttling backups

An off-site copy hit Google Drive's 403 Quota exceeded response for requests per minute. Adding --tpslimit 1 made the observed copy slower and did not fix the client quota. A limit on this process cannot isolate a client identifier shared with other users.

The correction is to configure a Google Cloud OAuth client you control using rclone's documented Drive procedure, authorize it interactively, then verify a small copy and restoration. Keep the client secret and refresh token out of publications, command history and agent logs. The current rclone guide says its shared client is being retired during 2026 and that creating your own is required.

Your own client still has quotas; it is not unlimited API access.

For a large-memory server with a provisioned 1 Gbps link, eight transfers and 128 MiB upload chunks are a starting experiment after that client correction. Eight buffered chunks account for roughly 1 GiB alone, before listings, other buffers and application memory. Compare completed bytes per second, retries and elapsed time against the previous settings.

Keep adaptive backoff and honor actual quota errors; use a measured transaction cap if your own quota requires it. Do not present these values as a guaranteed line-rate result or edit a running backup's configuration.

The operator kit contains the guarded copy command. The Ubuntu backup guidance covers the wider recovery task: transfer speed does not prove a consistent snapshot or a successful restore.

Fact-check notes and sources

Prompt hub and phone alert update, October 15, 2026: the routing, the rate_limit_event fields and the 12-second local answer are observations of our own build, not vendor documentation. Sources read October 15, 2026 (UTC): Claude Code permission modes, Claude Code programmatic use for stream-json output, Codex non-interactive mode for codex exec -, Cloudflare Access token validation, which says "We recommend validating the Cf-Access-Jwt-Assertion header", and the ntfy privacy policy and configuration guide.

Capacity and backup update, October 13, 2026: local instance probes were observed at 21:42:38 and 21:42:51 UTC. The limits changed from 128 to 1,024, and additional instances opened changed from 14 to 256. The concurrency budgets are recommendations, not stress-test maxima.

Official documentation was read through direct requests and an alternate-route check: Docker resource constraints at 21:42:22 UTC; Linux inotify at 21:43:17 UTC; Linux inotify limits and errors at 21:43:41 UTC; rclone Drive at 21:42:25 UTC; rclone transfer and transaction flags at 21:43:18 UTC; and Ubuntu backups at 21:43:42 UTC.

These six cited pages returned usable content on both routes. The backup error and effect of the one-transaction cap are an operational observation, not a controlled throughput benchmark. No network speed increase or completed migration is claimed.

Dedicated-server security update, October 13, 2026: these are recommended controls, not measurements of a deployed host. The OVHcloud guide, updated September 9, 2026 at 12:37 as displayed, was read October 13 at 20:40:03 UTC.

Ubuntu and upstream sources were checked October 13, 2026; the linked release table lists 26.04 LTS as current. The hardening section distinguishes general Ubuntu controls from OVH-specific services, adapts socket activation and Fail2ban overrides, and cites the Docker exposure caveat, Ollama binding and Restic restore instructions.

The commands are reviewed examples with access and recovery checks, not an unattended installer.

Parallel job update, October 13, 2026: the job practices and the 2 percent CPU observation come from work between October 12 at 07:00 and October 13 at 06:00 UTC, with five jobs running together on a 48 core server. They are operating observations, not a benchmark.

Sources checked October 13, 2026 from 05:57:28 to 05:57:52 UTC, each read directly and through the alternate route with readable content, none unmeasured.

The Claude Code permissions guide states that "Rules are evaluated in order: deny, then ask, then allow." The programmatic usage guide documents non-interactive runs with -p.

New security sources read October 13, 2026 (UTC):

Scroll to compare columns and rows when the table extends beyond the box.

Source Read UTC
OVH host security 20:40:03
Ubuntu releases 20:42:11
Ubuntu OpenSSH 20:41:48
Ubuntu users 20:42:02
Ubuntu automatic updates 20:41:58
Ubuntu firewall 20:41:53
Ubuntu SSH socket activation 20:42:07
systemd socket manual 20:47:43
Fail2ban overview 20:42:35
Fail2ban jail configuration 20:46:34
Fail2ban client manual 20:47:49
Docker firewalls 20:42:19
Docker published ports 20:42:22
Ollama configuration 20:42:25
OpenSSH forwarding 20:42:28
Restic restore 20:47:13
OVH Edge Network Firewall 20:40:44
OVH IPMI 20:40:56
OVH rescue 20:47:21
OVH backup overview 20:40:47

No guide text is reproduced in this addition; commands and configuration directives are shown as operational examples.

Workflow sources checked October 12, 2026 from 06:40:54 to 06:41:03 UTC: Email Trigger (IMAP), Telegram Trigger, Code, SSH, Send Email, Telegram and OpenSSH authorized_keys options.

Seven pages planned, seven measured with readable direct content and alternate-route checks, zero unmeasured. OpenSSH says the supplied command "is ignored" when the key has a forced command. The n8n nodes supply transport and workflow steps; sender authentication, argument validation, approval, sandboxing and output gates are application requirements, not guarantees supplied by those nodes.

Operational guidance updated October 12, 2026. The new practices are recommendations, not new measurements or claims that every integration is deployed. Existing dated tests retain their original conditions. The workstation operator guide supplies the detailed retrieval, scheduling, update and evidence policy.

  • Operational evidence: private OVH release, maintenance, proxy, keyring, and scheduled-job receipts were reviewed alongside connected AWS inventory. The table and timestamps above are sanitized observations from the stated window, with the later metadata check explicitly identified.

Private endpoints, account identifiers, credential material, and client details are omitted.

  • History correction: the earlier title attributed three months of unattended operation too broadly. Earlier AWS activity and the October 4 OVH migration are distinct periods.

Historical hardware and job counts are not presented as a fresh inventory here.

Linux native desktop Computer Use is a separate feature and is not included in that beta.

A successful application render and VM probe are not a completed owner Cowork task.

Match current instructions to the installed version and channel.

The latter accepts either webmasters or webmasters.readonly; the earlier statement that both scope choices were read-only was incorrect.

Related reading

← Back to Blog

Accessibility Options

Text Size
High Contrast
Reduce Motion
Reading Guide
Link Highlighting
Accessibility Statement

J.A. Watte is committed to ensuring digital accessibility for people with disabilities. This site conforms to WCAG 2.1 and 2.2 Level AA guidelines.

Measures Taken

  • Semantic HTML with proper heading hierarchy
  • ARIA labels and roles for interactive components
  • Color contrast ratios meeting WCAG AA (4.5:1)
  • Full keyboard navigation support
  • Skip navigation link
  • Visible focus indicators (3:1 contrast)
  • 44px minimum touch/click targets
  • Dark/light theme with system preference detection
  • Responsive design for all devices
  • Reduced motion support (CSS + toggle)
  • Text size customization (14px–20px)
  • Print stylesheet

Feedback

Contact: jwatte.com/contact

Full Accessibility Statement • Privacy Policy

Last updated: April 2026