← Part 1: Local LLM Setup  ·  AI Lab Portal Home

Part 1 established the local AI environment on Node A (Beelink SER9). Part 2 extends that environment to other devices — first over the local network, then from anywhere at all, using Tailscale.

This guide documents two milestones: getting Open WebUI reachable from an iPhone on the same Wi-Fi network as Node A (July 4, 2026), and then reaching it from the iPhone over cellular data, off that network entirely, using Tailscale (July 5, 2026).

Diagram of a laptop, an HP desktop, and a mobile phone connecting over the internet to Lab PC 1 and Lab PC 2
Interim target — the Mobile Phone joining the mesh alongside the two Lab PCs

Scope

This page documents the working mobile access path using Tailscale.

Tailscale is a mesh VPN — it creates a private, encrypted network (a "tailnet") between devices, no matter where each one physically is. Every device that joins gets its own stable address on that private network, and can reach every other device on it directly, as if they were all sitting on the same LAN. We're using it here because the lab's nodes and the phones that need to reach them aren't on the same physical network: Node A sits on the home Wi-Fi, while a phone might be on cellular data, a coffee shop's Wi-Fi, or anywhere else. Tailscale bridges that gap without exposing Open WebUI to the open internet or requiring router port-forwarding.

The iPhone does not connect directly to Node A through its local LAN address. Instead, the iPhone reaches Node A through the Tailscale tailnet, using Node A's Tailscale IP address.

Working path:

iPhone → Cellular or Wi-Fi Internet → Tailscale Tailnet → Node A → Open WebUI

Access URL:

http://ai-lab-b:8080

Tailscale MagicDNS now resolves the ai-lab-b hostname directly, so the raw Tailscale IP (100.115.162.13:8080) no longer needs to be memorized or bookmarked — the hostname works from any device on the tailnet. Node A still has LAN IP 192.168.88.239, but that address is documented only as its local network address, not the mobile access path.

Goal #

Allow an iPhone — whether on Wi-Fi or cellular data — to use Open WebUI running on Node A.

Diagram of iPhone (Tailscale IP 100.110.16.81) over cellular or Wi-Fi internet, through the Tailscale tailnet, reaching Node A (AI-Lab-B, Tailscale IP 100.115.162.13, LAN IP 192.168.88.239), running Open WebUI on TCP 8080
iPhone → Cellular/Wi-Fi Internet → Tailscale Tailnet → Node A → Open WebUI

Baseline Configuration #

HardwareBeelink SER9
Operating SystemWindows 11
Active Network InterfaceWi-Fi 2
LAN Address192.168.88.239
Subnet Mask255.255.255.0
Default Gateway192.168.88.1
Tailscale Address100.80.190.11
iPhone LAN Address (during testing)192.168.88.240
PowerShell showing hostname command returning AI-LAB-B
Confirming the hostname
ipconfig output showing the Tailscale adapter and Wi-Fi 2 with address 192.168.88.239
ipconfig — Tailscale adapter (100.80.190.11) and Wi-Fi 2 (192.168.88.239) side by side

Tailscale was already present on the node during this phase, but signed into the wrong identity — see Tailscale Account / Tailnet Lessons. Once corrected, the node's Tailscale address changed to 100.115.162.13, used throughout the remote-access phase below.

Tailscale identities (after correction)

Node A (ai-lab-b)100.115.162.13
Node B100.81.51.91
iPhone (iphone171)100.110.16.81

All three devices are members of the same shared AI Lab tailnet. Node A initially joined a different, personal tailnet by mistake — see Tailscale Account / Tailnet Lessons.

Initial Open WebUI Binding #

LocalAddress LocalPort OwningProcess ------------ --------- ------------- 127.0.0.1 8080 19748
Get-NetTCPConnection output showing Open WebUI listening only on 127.0.0.1:8080
The initial listener — loopback only

127.0.0.1 is the loopback interface — Open WebUI was reachable only from the node itself. Other devices on the LAN could not connect to that listener.

The owning process was identified as the Open WebUI Desktop app's bundled Python runtime:

Get-Process output identifying the python.exe process serving Open WebUI
Identifying the process behind the listener

explicitly launching with:

open-webui.exe serve --host 127.0.0.1 --port 8080
Get-CimInstance output showing the full command line with --host 127.0.0.1 --port 8080
The full command line, confirming the loopback-only launch

A server bound to 127.0.0.1 only accepts connections that originate from the same machine — that's why the iPhone couldn't reach it yet.

Required Open WebUI Binding #

open-webui serve --host 0.0.0.0 --port 8080

0.0.0.0 tells the server to listen on all available IPv4 interfaces, not just loopback. Clients never browse to 0.0.0.0 itself — the iPhone instead uses the node's actual LAN address:

http://192.168.88.239:8080/

Open WebUI Desktop Configuration Investigation #

The Open WebUI Desktop config file included:

"localServer": { "port": 8080, "serveOnLocalNetwork": false, "autoUpdate": true }
Open WebUI Desktop config.json showing serveOnLocalNetwork set to false
The likely culprit: serveOnLocalNetwork: false

Attempts to change this setting did not produce a persistent LAN-enabled startup — the Desktop app continued launching with --host 127.0.0.1 on its own. Persistent LAN-enabled Open WebUI startup remains unresolved. The server that worked for this session was launched manually, and the window running it has to stay open.

Initial iPhone Failures #

Early symptoms included several browsers attempting HTTPS instead of plain HTTP, secure-connection errors, roughly 60-second connection timeouts, an Invalid HTTP request received log line from Open WebUI, and later a WebSocket WinError 121 semaphore timeout. None of this yet identified whether the real problem was Open WebUI, Windows Firewall, the Windows network profile, or browser protocol behavior.

iPhone Safari showing 192.168.88.239 took too long to respond, ERR_CONNECTION_TIMED_OUT
Safari: connection timed out
iPhone DuckDuckGo browser showing the request timed out
A second browser, same result

Two different browsers, same dead end — a good early sign the problem wasn't the browser.

Basic Network Connectivity Test #

ping 192.168.88.240 Sent = 4, Received = 4, Lost = 0

This proved basic IP connectivity between the two devices — it did not prove that TCP port 8080, or any application port, was actually reachable.

Python HTTP Server Diagnostic Test #

To take Open WebUI out of the test path entirely, a plain Python HTTP server was started:

python -m http.server 8000 --bind 0.0.0.0 Serving HTTP on 0.0.0.0 port 8000

The iPhone still couldn't reach http://192.168.88.239:8000/, and no request showed up in the server console. That was actually useful: it removed Open WebUI as a suspect, confirmed the failure was at the network/firewall layer, and pointed the investigation at Windows itself.

Windows Network Profile Discovery #

Get-NetConnectionProfile | Format-Table InterfaceAlias,NetworkCategory,IPv4Connectivity InterfaceAlias NetworkCategory IPv4Connectivity -------------- --------------- ---------------- Tailscale Private LocalNetwork Wi-Fi 2 Public Internet

The home Wi-Fi interface was classified Public. Windows applies much more restrictive inbound behavior to Public networks than Private ones. Changing it:

Set-NetConnectionProfile -InterfaceAlias "Wi-Fi 2" -NetworkCategory Private # Verified: Wi-Fi 2 Private Internet

Temporary Port 8000 Firewall Rule #

New-NetFirewallRule -DisplayName "AI Lab Test HTTP 8000" ` -Direction Inbound -Action Allow -Protocol TCP ` -LocalPort 8000 -Profile Private

After this rule was added, the iPhone successfully reached the Python server:

192.168.88.240 - - [04/Jul/2026 11:32:32] "GET / HTTP/1.1" 200 -

This was the decisive network-layer validation — the LAN path itself was proven to work.

Side Discovery: Portal Mobile Preview #

While that temporary Python server was still running, the AI Lab Portal's own local files were browsed to from the iPhone and loaded successfully — including this Field Guide and its images. That's a useful secondary discovery: the Portal can be previewed from a mobile device on the local LAN before changes are pushed or deployed.

One caution, though: the temporary server was started from the Windows user profile root, which exposed the entire directory tree beneath it to any device that could reach port 8000 — not just the Portal folder. That's not a configuration to leave running. For future mobile-preview testing, the server should be started from inside the Portal directory specifically, so only that folder is exposed. See Security and Cleanup.

Open WebUI Firewall Rule #

New-NetFirewallRule -DisplayName "AI Lab Open WebUI 8080" ` -Direction Inbound -Action Allow -Protocol TCP ` -LocalPort 8080 -Profile Private

With the manually launched, LAN-bound Open WebUI server running:

LocalAddress LocalPort OwningProcess ------------ --------- ------------- 0.0.0.0 8080 12816

the iPhone browsed to http://192.168.88.239:8080/ and Open WebUI loaded.

Final Validation #

192.168.88.240:50598 - "GET / HTTP/1.1" 200 192.168.88.240:50598 - "GET /manifest.json HTTP/1.1" 200 192.168.88.240:50599 - "GET /static/loader.js HTTP/1.1" 200 192.168.88.240:50600 - "GET /static/custom.css HTTP/1.1" 200
Get-NetTCPConnection output showing an Established connection on port 8080 from the iPhone's LAN address 192.168.88.240
Established — the iPhone holding an open connection to Open WebUI on port 8080

No screenshot of the loaded Open WebUI chat screen itself survived the session, but this is stronger proof than a photo would be: it's the network stack itself confirming a live, established connection from the iPhone's address to the Open WebUI port.

iPhone 192.168.88.240 │ │ Home Wi-Fi ▼ Node A (AI-LAB-B) 192.168.88.239 │ │ TCP 8080 ▼ Open WebUI 0.0.0.0:8080 │ ▼ Local LLM Models
Mobile LAN Access: SUCCESS

Lessons Learned

  1. A server listening on 127.0.0.1 is not reachable from other LAN devices.
  2. Binding to 0.0.0.0 allows a server to accept LAN connections, subject to firewall configuration.
  3. A successful ping does not prove an application port is reachable.
  4. A minimal Python HTTP server is a good way to separate application failures from network/firewall failures.
  5. Windows' Public network profile can silently block inbound LAN access that a Private profile allows.
  6. Explicit firewall rules give predictable inbound access.
  7. Browser HTTPS upgrades can produce misleading errors when testing an HTTP-only service.
  8. Verify the server is actually listening before blaming the client device.
  9. Persistent LAN-enabled Open WebUI startup was never fixed at the Desktop-app level, but a one-click Start/Stop script (see Startup Automation) makes that a non-issue in practice.
  10. Temporary diagnostic servers and firewall rules should be removed once they're no longer needed.

Security and Cleanup

The temporary Python HTTP server exposed the full directory tree beneath the Windows user profile — not just the Portal folder — to any device that could reach port 8000.

Required cleanup on the node:

Stop the temporary Python HTTP server, if still running. Remove-NetFirewallRule -DisplayName "AI Lab Test HTTP 8000" # Verify port 8000 is no longer listening: Get-NetTCPConnection -State Listen | Where-Object { $_.LocalPort -eq 8000 }

The dedicated Open WebUI port-8080 firewall rule should be kept. For future Portal mobile-preview testing, start the server from inside the Portal folder specifically:

Set-Location "...\AI-Lab\Portal" python -m http.server 8000 --bind 0.0.0.0

Startup Automation #

The Open WebUI Desktop app never reliably picked up a LAN-enabled launch on its own (see Open WebUI Desktop Configuration Investigation). Rather than keep fighting the Desktop app's config, a pair of one-click batch scripts now bring the whole stack up and down instead — checking whether Ollama and Open WebUI are already running, starting Ollama if not, warming up the default model before Open WebUI comes up, and launching Open WebUI itself.

Start AI Lab

@echo off echo version 2.200 title Start AI Lab echo Checking Ollama server... tasklist | findstr /I "ollama.exe" >nul if errorlevel 1 ( echo Starting Ollama server... start "Ollama Server" /min cmd /c "ollama serve" timeout /t 5 /nobreak >nul ) else ( echo Ollama is already running. ) echo. echo Warming up qwen3:8b... ollama run qwen3:8b "READY" >nul 2>&1 echo qwen3:8b is ready. echo. echo Checking Open WebUI... tasklist | findstr /I "open-webui.exe" >nul if errorlevel 1 ( echo Starting Open WebUI... start "" "%LOCALAPPDATA%\Programs\open-webui\open-webui.exe" ) else ( echo Open WebUI is already running. ) echo. echo AI Lab startup complete. pause

Stop AI Lab

@echo off echo version 2.200 title Stop AI Lab echo. echo Stopping Open WebUI... taskkill /F /IM open-webui.exe echo. echo Stopping Ollama... taskkill /F /IM ollama.exe echo. echo AI Lab shutdown complete. pause

This isn't a true auto-start-on-boot service — it's still a manual double-click — but it turns "reconstruct the launch command from memory" into "run one script," which is most of what actually mattered day to day.

Troubleshooting Notes #

The Open WebUI Desktop app's own window sometimes showed a plain Failed to fetch error, even while the underlying server was healthy. Browsing directly to the server proved it was fine:

curl http://127.0.0.1:8080 curl http://localhost:8080 # both returned the Open WebUI HTML page

The Desktop app's own shell turned out to be less reliable than just using a browser — which is also, conveniently, exactly what the iPhone has to do anyway. Browser access became the preferred path for both troubleshooting and everyday use.

Remote Access with Tailscale #

Status: SUCCESS

With LAN access working and the startup scripts in place, the next step was reaching Open WebUI from the iPhone over cellular data — off the home Wi-Fi entirely — using Tailscale.

The first attempt didn't work: Node A's Tailscale client was signed into the wrong identity, on a personal tailnet rather than the shared AI Lab tailnet that Node B and the iPhone already belonged to. Two devices on different tailnets can't see each other over Tailscale, no matter how correctly everything else is configured.

The fix was to sign Node A out of Tailscale and back in, explicitly selecting the shared AI Lab tailnet this time instead of the personal one:

"C:\Program Files\Tailscale\tailscale.exe" logout "C:\Program Files\Tailscale\tailscale.exe" login

After signing in under the correct tailnet, the join request still needed the tailnet admin to approve it before Node A actually showed up for the other members — a deliberate access control step, not a bug.

Once approved, tailscale status showed all three devices on the same tailnet:

100.115.162.13 Node A (ai-lab-b) windows 100.81.51.91 Node B windows 100.110.16.81 iphone171 iOS

With Wi-Fi turned off, the iPhone loaded Open WebUI over cellular data using Node A's Tailscale address:

http://100.115.162.13:8080

Login succeeded, qwen3:8b was selected, and a test question — "Who invented AI?" — got a real response back, fully over cellular with no Wi-Fi involved at all.

Mobile Access via Tailscale: SUCCESS

Tailscale Account / Tailnet Lessons #

Lessons learned

  1. A device's sign-in identity and its Tailscale tailnet membership are two different things — signing in doesn't automatically put you on the tailnet you meant to join.
  2. It's easy to land on the wrong tailnet during sign-in, especially when one person has both a personal account and a shared/admin account available.
  3. Two devices on different tailnets are invisible to each other, even though both individually show as "connected" to Tailscale.
  4. Joining a new tailnet can require the tailnet admin's approval before the device actually appears for other members.
  5. tailscale logout followed by tailscale login, explicitly selecting the correct tailnet at sign-in, is the fix.

Security Note #

Safari flags the connection as "Not Secure" because Open WebUI is served over plain HTTP, not HTTPS — whether reached via the raw IP or the ai-lab-b MagicDNS hostname, there's no TLS certificate behind it. The traffic itself isn't unprotected, though: Tailscale encrypts the device-to-device tunnel itself, so the connection is private between the iPhone and Node A even without HTTPS layered on top.

A cleaner long-term fix would still be HTTPS — the MagicDNS hostname (ai-lab-b) is now in use in place of the raw IP, resolving the naming half of this note.

What's Next

Continue to Part 3

Reliable Remote Access — idle states, Tailscale, and making the AI server behave like always-on infrastructure instead of a desktop client.

Read →

← Part 1: Local LLM Setup  ·  Part 3: Reliable Remote Access →  ·  AI Lab Portal Home

Mobile Access — LAN and Tailscale: SUCCESS