The installer detects Termux automatically and:

• updates the Termux package lists and installs only the packages you are missing (python, git, curl)
• checks that Python is new enough (3.14 or newer)
• keeps the source checkout in ~/.luicode-src, never in ~/.luicode, which holds your configuration and data
• installs luicode into that checkout with pip install -e .
• adds the directory holding luicode and luicode-server to your PATH from ~/.bashrc or ~/.zshrc, inside a single managed # >>> LUICode PATH >>> block so reruns never duplicate it
• verifies that both commands run, and prints the web interface URL

Open a new Termux session afterwards.

Good to know

• Coding agents (Claude Code, Codex, OpenCode, …) are installed separately with the Linux installer. The Termux one-command install covers the gateway itself.
• termux-wake-lock is never run for you. The installer only prints it as an optional tip.
• Local Whisper and browser automation are not available on Android.

See docs/android.md for persistence, wake locks, auto-start (Termux:Boot), notifications (Termux:API), LAN access, and how to update or uninstall.

LM Studio — Start LM Studio's local server, load a tool-capable model, and use the identifier LM Studio shows, with the lmstudio/ prefix. Default URL: http://localhost:1234/v1.

llama.cpp — Start llama-server with its OpenAI-compatible Chat Completions API and enough context for the model. Use the local model ID with the llamacpp/ prefix. LLAMACPP_BASE_URL defaults to http://localhost:8080/v1; luicode accepts either the server root or an explicit /v1 suffix.

Ollama — Pull and serve a model:

ollama pull llama3.1
ollama serve

Use the tag shown by ollama list with the ollama/ prefix. OLLAMA_BASE_URL defaults to http://localhost:11434; luicode accepts either the root URL or an explicit /v1 suffix.

General: prefer tool-capable models for coding agents. Local models also need enough context for the agent's system prompt and tool definitions.

Subscription sign-in

• OpenAI / ChatGPT uses your ChatGPT subscription instead of an API key. Go to Providers → OAuth providers → OpenAI / ChatGPT → Connect in the Admin UI and finish signing in through your browser. Restart any already-running agent after connecting.

• GitHub Copilot uses your signed-in GitHub account and subscription.

  1. Install Copilot CLI 1.0.83 and make sure it's on your PATH.
  2. Choose Providers → OAuth providers → GitHub Copilot → Connect. luicode reuses the native profile or shows a GitHub device code when sign-in is needed. (You can also sign in first with copilot login --device-code.)
  3. Select a concrete github_copilot/<model-id> from the discovered list. Available models and quotas depend on your subscription and organization policies.
  4. Restart any already-running agent.

  Disconnect stops luicode's use and leaves the native login intact. luicode pins its SDK and CLI compatibility because direct endpoint access is experimental.

Cloud and API providers

• OpenAI API uses a separate Platform API key. Enter it under Providers → Cloud providers → OpenAI API → Configure. The model list may include IDs that can't handle coding requests, so choose a text-generation model.
• Azure OpenAI uses the deployment names from your resource. Set AZURE_OPENAI_BASE_URL to the complete v1 endpoint (for example https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/) and select a deployment that supports Chat Completions. If the deployment doesn't appear in the dropdown, enter its name as a custom model slug.
• Amazon Bedrock: set BEDROCK_BASE_URL to the URL for the same region as your API key, then select one of the listed models.
• Vertex AI uses Google Application Default Credentials instead of an API key. Locally, run gcloud auth application-default login once (service-account files and attached service accounts also work). Set VERTEX_PROJECT_ID, and optionally change VERTEX_LOCATION from its global default.
• Cloudflare requires both its API token and account ID.
• Mistral Codestral uses a separate key from Mistral La Plateforme.
• Ollama Cloud: use the exact model IDs shown in the model picker. Local Ollama uses the separate ollama/ prefix.
• OpenCode Zen and OpenCode Go share OPENCODE_API_KEY but use the explicit opencode_zen/ and opencode_go/ model prefixes.

Plans that have two kinds of keys (the keys and endpoints are not interchangeable)

• Kimi: subscription keys (Kimi Code) use kimi_code/; API credit keys use kimi/. Kimi Code plans are for personal interactive coding-agent use under Kimi's community guidelines.
• QwenCloud: Coding Plan keys use qwencloud_coding/; Token Plan keys use qwencloud/. The Coding Plan is for local, personal, interactive coding-agent use under the Coding Plan terms.

MODEL is the fallback for every request. To override an individual Claude Code tier, select a model for MODEL_FABLE, MODEL_OPUS, MODEL_SONNET, or MODEL_HAIKU. Select None to use MODEL.

Open Admin UI → Model config → Reasoning and choose a behavior:

Providers that don't support a selected control keep their own behavior.

1. Create a bot in the Discord Developer Portal.
2. Enable Message Content Intent, and invite the bot with read, send, message-history, and Manage Messages permissions (so /clear can remove user prompts).
3. Set Messaging Platform to discord.
4. Enter Discord Bot Token, Allowed Discord Channels, and an absolute Allowed Directory.
5. Apply the settings and restart the server if requested.

1. Create a bot with @BotFather.
2. Get your numeric user ID from @userinfobot. In groups, grant the bot permission to delete messages.
3. Set Messaging Platform to telegram.
4. Enter Telegram Bot Token, Allowed Telegram User ID, and an absolute Allowed Directory.
5. Apply the settings and restart the server if requested.

1. In Admin UI → Messaging → Voice, enable voice notes.
2. Select nvidia_nim and choose a supported model.
3. Configure your NVIDIA NIM API key on the Providers page (NVIDIA_NIM_API_KEY).

This is the only option on Android/Termux.

Not available on Android. Rerun the installer with the local voice option.

macOS / Linux

# CPU or CUDA
curl -fsSL "https://raw.githubusercontent.com/Luigibarte4563/luicode/main/scripts/install.sh" | sh -s -- --voice-local

# CUDA 13.0
curl -fsSL "https://raw.githubusercontent.com/Luigibarte4563/luicode/main/scripts/install.sh" | sh -s -- --voice-local --torch-backend cu130

Windows (PowerShell)

# CPU or CUDA
& ([scriptblock]::Create((irm "https://raw.githubusercontent.com/Luigibarte4563/luicode/main/scripts/install.ps1"))) -VoiceLocal

# CUDA 13.0
& ([scriptblock]::Create((irm "https://raw.githubusercontent.com/Luigibarte4563/luicode/main/scripts/install.ps1"))) -VoiceLocal -TorchBackend cu130

Then restart luicode-server. In Admin UI → Messaging → Voice, enable voice notes, select cpu, cuda, or nvidia_nim, and choose the Whisper model. Gated local models need HUGGINGFACE_API_KEY.

Install

uv sync --extra browser

This installs browser-harness and cdp-use. You can also select the browser automation option in the installer, where available on your platform.

Requirements

• Chrome or Chromium with remote debugging enabled (managed automatically by browser-harness)
• The browser-harness daemon starts on first use

What agents can do

• Navigate to URLs and wait for page load
• Observe page state: interactive elements (buttons, inputs, dropdowns, links) with labels and metadata
• Click elements by their observed index
• Fill text into inputs, textareas, and comboboxes
• Select options from dropdown menus
• Scroll the page up or down
• Wait for the page to settle after interactions
• Run multi-step tasks as a sequence of actions

Notes

• The browser runs in a background tab with focus emulation to prevent throttling.
• TypeSafe integration for structured decision-making is not included in this MVP.

Instead of driving the browser step by step, you can hand a whole web task to a browser agent. LUICode injects a single browse_web(url, goal) tool into the request; when the model calls it, the gateway runs Jev Ultrafast in a worker thread, returns the result to the model as a tool_result, and continues the same turn.

Setup (all in the Admin UI)

1. Open Browser Agent at http://127.0.0.1:8082/admin/browser.
2. Click Connect. The dialog lists every file and setting that will change before anything is written.
3. Enter your TypeSafe API key, an optional text-model key, and an optional domain allowlist, then confirm.

There are no terminal steps: Connect installs Jev (from its git repository, since it is not published to PyPI), saves the keys to the managed environment, and enables the tool. Disconnect disables it and clears both keys.

Settings

Privacy — please read this first

Jev drives a real Chrome profile and sends page state to an outside service. This feature is off by default, opt-in, and deliberately locked down:

• Browsing is limited to an allowlist. With an empty list, each new domain needs approval in the Admin UI.
• Private and loopback addresses are blocked unless the host is explicitly allowlisted, so localhost testing still works.
• Only http and https URLs are accepted.
• The Connect dialog states that page state is processed by TypeSafe and the text-model provider, and requires confirmation. LUICODE's usual "all processing local" claim does not cover this feature.
• API keys are stored in the managed environment, masked in the UI, never logged, and cleared on Disconnect.
• Page text is wrapped as untrusted data so a page cannot issue instructions to your agent.

Current limits

• Interception works for the Anthropic Messages protocol. OpenAI Responses and Chat Completions are not covered yet.
• No MCP server is exposed yet.
• Run history appears on the Browser Agent tab, not in the Usage dashboard.
• Requires the browser extra above, plus a TypeSafe key.

Not available on Android/Termux (no embeddable Chromium).

Browser automation is exposed through the BrowserToolsPort protocol in the application layer:

from luicode.application.browser_tools.ports import BrowserToolsPort


# In your handler/service
async def my_handler(browser_tools: BrowserToolsPort):
    await browser_tools.navigate("https://example.com")
    state = await browser_tools.observe()
    # state.elements contains indexed interactive elements
    await browser_tools.click(node_id=5)  # Click the 5th element
    await browser_tools.fill(node_id=3, text="search query")
    await browser_tools.wait()

The runtime implementation (BrowserToolsClient in luicode.runtime.browser_tools) handles:

• CDP session management via browser-harness
• Atomic DOM snapshots with element indexing
• Staleness detection (page fingerprint guards)
• Post-input observation (autocomplete suggestions, animations)
• Screenshot capture (optional)

The higher-level Browser Agent is a separate path. BrowserWebInterceptor (luicode.application.browser_agent.interception) injects the browse_web schema, detects the model's call, delegates to JevBrowserAgent, and re-enters the provider with a tool_result. Policy lives in BrowserAgentService.check_url, and every task is recorded for run history.