Run an AI browser agent with your own remotely reachable model endpoint
WebBrain is an open-source browser extension that can read pages, answer questions, and automate browser tasks with a selected language model. This guide first explains how to install WebBrain from its source repository, load it into Chrome or Firefox, and verify that the extension works. We then configure an OpenAI-compatible model server separately and show how to make that HTTP endpoint reachable through Localtonet. WebBrain does not open a listening port itself, so the tunnel belongs in front of the model server, not the browser extension.
Understand the WebBrain and Localtonet architecture
WebBrain is an AI browser agent distributed as an extension for Chrome, Firefox, and Microsoft Edge. It appears in a browser side panel and can work in several modes. Ask mode is read-only and is intended for reading pages and answering questions. Act mode can interact with pages by clicking, typing, scrolling, navigating, uploading, downloading, and filling forms. Dev mode adds access to page source, styles, console information, network information, and reversible page edits.
The most important networking detail is that WebBrain is not a self-hosted web server. Installing the extension does not create a local website, API port, or service that Localtonet can expose. Instead, WebBrain can send requests to an OpenAI-compatible HTTP API. That API might be provided by llama.cpp, Ollama, vLLM, SGLang, LM Studio, Jan, LocalAI, GPT4All, or another compatible implementation.
The model server and WebBrain therefore have distinct responsibilities. WebBrain supplies the browser interface and agent workflow, while the model server performs inference. If that server only listens on a machine inside a private network, a browser on another network cannot normally reach it. With Localtonet, our client establishes an outbound connection to a relay server and provides a public address for the configured local target. No inbound router port forwarding, firewall changes, VPN setup, or public IP address is required.
Configure Localtonet for the machine and port where the OpenAI-compatible model server is listening. Do not search for a WebBrain port because the browser extension does not provide one.
Prerequisites
To load WebBrain from source, you need Git, a supported browser, and permission to enable the browser's extension development features. Chrome uses Developer mode and an unpacked extension directory. Firefox uses its runtime debugging page and a manifest file. A Firefox extension loaded this way is temporary and is removed when Firefox restarts. Permanent Firefox distribution requires signing through addons.mozilla.org.
Connecting to your own model also requires a running OpenAI-compatible server and a model suitable for WebBrain's context requirements. The WebBrain documentation recommends a model with at least a 16,000-token context window. An 8,000-token context can work with the Compact tier, while 4,000 tokens is documented as too small for the system prompt and tool schemas.
For the remote-access stage, install the Localtonet client on the computer that runs the model server or on another device that can reach that server over the local network. You also need a device-specific Localtonet authentication token and an available relay server selection from the current dashboard. Do not copy a token into documentation, source control, screenshots, or shared configuration files.
Install WebBrain from source
WebBrain can also be installed from browser extension stores, but source loading is useful for inspecting the checked-out project or testing repository builds. The following sequence follows the repository's documented source-loading instructions.
Clone the WebBrain repository
Open a terminal in the parent directory where you want to keep the project, then clone the official repository.
git clone https://github.com/webbrain-one/webbrain.gitLoad the extension in Chrome
For Chrome, open chrome://extensions/, enable Developer mode, select Load unpacked, and choose the webbrain/src/chrome folder from the cloned repository.
Load the extension in Firefox
For Firefox, open about:debugging#/runtime/this-firefox, select Load Temporary Add-on, and choose src/firefox/manifest.json inside the cloned repository. This temporary installation is removed when Firefox restarts.
Open and verify the side panel
Select the WebBrain icon in the browser to open its side panel. Begin with a low-risk read-only request, such as asking it to summarize the current page. Confirm that the panel opens and returns a response before changing providers or enabling browser actions.
Start with read-only Ask mode while validating the installation and model connection. Act and Dev modes can perform more consequential operations. Review the active page, requested permissions, generated plan, and any form data before allowing actions on accounts, administrative interfaces, financial pages, or other sensitive systems.
Start and verify an OpenAI-compatible model server
Choose one server implementation and follow its own installation and model-download documentation. The examples below are the startup patterns documented by WebBrain. Replace model placeholders only with values appropriate for the server and model you have actually installed.
| Server | Documented startup or address | WebBrain endpoint pattern |
|---|---|---|
| llama.cpp | llama-server -m your-model.gguf --port 8080 |
Local server on port 8080 |
| Ollama | ollama serve |
Port 11434 with the /v1 path |
| vLLM | vllm serve your-model --port 8000 |
Port 8000 with the /v1 path |
| SGLang | python -m sglang.launch_server --model-path your-model --port 30000 |
Local server on port 30000 |
| LM Studio | Start its local server through the application | Port 1234 with the /v1 path |
| LocalAI | Use the server's documented installation and startup process | Port 8080 with the /v1 path |
Before adding a tunnel, verify the server from the same machine on which it runs. Use the server's documented health, models, or chat-completions request rather than assuming that an open process is ready. Confirm that the expected model is loaded, that the OpenAI-compatible route responds, and that any required API credential works. This local verification separates model-server problems from later tunnel or browser configuration problems.
The exact API base URL can differ by implementation. Some documented integrations use a /v1 path, while others may expect that path to be added in WebBrain's provider configuration. Preserve the path required by your server when replacing the local origin with the Localtonet public address.
Expose the model endpoint with Localtonet
Once the model API works locally, create an HTTP tunnel for that service. Our HTTP tunnel points to the local IP address and port reachable from the Localtonet client device. HTTP tunnels can use a random subdomain, a supported custom subdomain, or a custom domain, and each process type serves the configured content at a public HTTPS address. Exact custom-domain DNS requirements should always be checked against current documentation before changing DNS records.
Install and run the Localtonet client
Run the Localtonet client on the model-server computer or on a device that can reach the model server's local IP address and port.
Select the client device
Authenticate or select the intended device using its device-specific token. Keep the token private and never substitute a guessed value.
Select an available relay server
Choose a currently available relay server or region from the Localtonet dashboard. Availability can vary, so this guide does not hardcode a server code.
Create the HTTP tunnel configuration
Create an HTTP tunnel and set its local target to the model server's reachable IP address and verified port. Use the port belonging to the server you started, such as 8080, 11434, 8000, or 30000.
Start the tunnel
Use the Start button after reviewing the configuration. Creating a tunnel does not automatically make it run. The public address is available only while the selected client is connected and the tunnel is running.
Test the assigned public address
Test the public HTTPS address with the same documented API route used during local verification. If the model expects /v1, preserve that path when constructing the remote API base URL.
For current dashboard details and configuration behavior, consult our Localtonet HTTP tunnel documentation. Dashboard options, relay availability, and plan-specific capabilities can change, so confirm current values rather than copying old screenshots or hardcoded server selections.
A public URL can receive traffic from outside the private network. Enable authentication supported by the model server or a suitable gateway, use strong credentials, grant only the access required, and avoid exposing administrative routes. Do not place API keys in a public URL. Stop or delete the tunnel when remote access is no longer needed.
Connect WebBrain to the tunneled endpoint
Open WebBrain's settings and choose the provider card appropriate for your server, or use its generic local OpenAI-compatible option when that matches the deployment. Replace the local origin with the public HTTPS address assigned to the Localtonet HTTP tunnel. Append the server's required OpenAI-compatible path, commonly /v1 for implementations such as Ollama, vLLM, and LM Studio.
Enter a model name only when the provider or server requires one. If authentication is enabled, configure the credential through the provider settings rather than embedding it in the endpoint URL. Because browser extension permissions, cross-origin behavior, and server authentication implementations can differ, test the exact combination you operate. We should not assume that every OpenAI-compatible server has identical CORS, authorization, or route behavior.
Begin with a simple Ask-mode prompt on a non-sensitive page. If the request fails, test in layers: verify the model server locally, verify the Localtonet public route independently, confirm the API path, then recheck the provider settings in WebBrain. An HTTP status response usually indicates that the request reached a server, while connection failures may indicate that the model server, Localtonet client, or tunnel is not running.
Frequently asked questions
Does WebBrain itself need a Localtonet tunnel?
No. WebBrain is a browser extension and does not expose a listening port. The Localtonet HTTP tunnel targets the separate OpenAI-compatible model server that WebBrain needs to reach remotely.
Which local model servers can WebBrain use?
Its documentation includes llama.cpp, Ollama, vLLM, SGLang, LM Studio, Jan, LocalAI, and GPT4All examples. The endpoint must provide the OpenAI-compatible behavior expected by the selected WebBrain provider configuration.
Why does the WebBrain connection work locally but fail remotely?
Check that the Localtonet client is connected, the HTTP tunnel has been started, the local target uses the correct IP address and port, and the public URL includes the required API path. Also verify server authentication and browser-related cross-origin requirements.
Does creating a Localtonet tunnel start it automatically?
No. After creating the configuration, start it with the Start button. The tunnel remains available only while the selected client device is connected and the tunnel is running.
Can I expose an unauthenticated local model server?
Technically reachable does not mean safely deployable. A public unauthenticated inference endpoint can be used by unintended clients and may expose model or operational capabilities. Add authentication through the server or an appropriate gateway, apply least privilege, and limit how long the tunnel runs.
Is the Firefox source installation permanent?
No. Loading src/firefox/manifest.json from Firefox's runtime debugging page creates a temporary add-on that is removed when Firefox restarts. Permanent installation requires signing through addons.mozilla.org.
Connect your model server with Localtonet
After WebBrain works locally and your OpenAI-compatible API passes local verification, use a Localtonet HTTP tunnel to provide a remotely reachable HTTPS endpoint without configuring inbound router port forwarding.
Get Started Free →
