### Set up Omnigent Credentials

Source: https://omnigent.ai/docs

Execute this command to start the credential setup wizard. It will detect existing credentials and prompt for any missing ones.

```bash
omni setup
```

--------------------------------

### Setup Omnigent Credentials

Source: https://omnigent.ai/docs/build/models

Initiate the Omnigent setup wizard to add, set, or remove credentials for model providers.

```bash
omni setupcopy
```

--------------------------------

### Run Polly

Source: https://omnigent.ai/quickstart/polly

Starts Polly and opens a web UI at http://localhost:6767. You can also use `omni` to start Polly.

```bash
omni polly
```

--------------------------------

### Start Omnigent Server and Host

Source: https://omnigent.ai/docs/interact/web-ui

Start the local Omnigent server and web UI in the background, and register the current machine as a host. This is for browser-first mode.

```bash
omni server start   # start the local server + web UI in the background
omni host           # (separate terminal) register this machine as a hostcopy
```

--------------------------------

### Full Custom Agent Configuration Example

Source: https://omnigent.ai/docs/use/custom-agents

A comprehensive example of a custom agent configuration file, including spec version, name, prompt, executor, environment, tools, and policies.

```yaml
spec_version: 1
name: coding_agent
prompt: |
  You are a coding agent. Inspect files before editing, run targeted tests,
  and summarize changes with validation results.

executor:
  type: omnigent
  config:
    harness: claude
  model: claude-sonnet-4-6

os_env:
  type: caller_process
  cwd: .
  sandbox:
    write_paths: [. ]
    allow_network: true

tools:
  repo_search:
    type: function
    callable: my_package.tools.repo_search

policies:
  rate_limit:
    type: function
    handler: omnigent.policies.builtins.safety.max_tool_calls_per_session
    factory_params:
      limit: 50
```

--------------------------------

### Install Omnigent with Cloud Sandbox Support

Source: https://omnigent.ai/docs/deploy/cloud-sandbox-host

Install the Omnigent package with the necessary dependencies for either Modal or Daytona cloud sandbox hosts.

```bash
pip install 'omnigent[modal]'       # for Modal
pip install 'omnigent[daytona]'     # for Daytonacopy
```

--------------------------------

### Install Omnigent AI

Source: https://omnigent.ai/

Use this command to install Omnigent AI via the official installation script. Ensure you have curl installed.

```bash
curl -fsSL https://omnigent.ai/install.sh | sh
```

--------------------------------

### Skill with Resource Files

Source: https://omnigent.ai/docs/build/prompts

Example of a skill directory structure that includes a 'references' subdirectory for additional documentation and a 'scripts' subdirectory for executable files.

```directory structure
skills/
  deploy/
    SKILL.md
    references/
      runbook.md
      checklist.md
    scripts/
      validate.sh
```

--------------------------------

### Example Orchestrator Skill Organization

Source: https://omnigent.ai/docs/build/prompts

Shows the directory structure for an example orchestrator ('Polly') that bundles multiple skills for different workflow steps.

```directory structure
examples/polly/
  config.yaml
  skills/
    investigate/
      SKILL.md      # read-only investigation workflow
    fanout/
      SKILL.md      # parallel task dispatch
    cross-review/
      SKILL.md      # cross-vendor PR review
```

--------------------------------

### Provide a Task to Polly

Source: https://omnigent.ai/quickstart/polly

This is an example task for Polly to refactor authentication modules and add tests. Polly will break this down into sub-tasks for different AI agents.

```bash
Refactor the authentication module into separate files for OAuth, JWT, and session handling. Add tests for each.
```

--------------------------------

### Session-Level Policy Examples (Chat)

Source: https://omnigent.ai/docs/policies/overview

Add policies by describing them in plain language to your Omnigent. The Omnigent will select, configure, and seek approval for the appropriate policy.

```plaintext
You: Add a policy that asks me before running any shell commands.

You: Limit this session to $5 of LLM spend.

You: Block access to all GitHub repos except myorg/frontend.copy
```

--------------------------------

### Write a Policy Function with Parameters (Factory Pattern)

Source: https://omnigent.ai/docs/policies/custom

Use the factory pattern to create policies that accept configuration parameters. This example creates a policy to block specific domains.

```python
def block_domains(blocked_domains: list[str]) -> callable:
    blocked = frozenset(d.lower() for d in blocked_domains)

    def evaluate(event: PolicyEvent) -> PolicyResponse | None:
        if event["type"] != "tool_call":
            return None
        url = event["data"].get("url", "")
        for domain in blocked:
            if domain in url.lower():
                return {"result": "DENY", "reason": f"Domain {{domain}} blocked."}
        return {"result": "ALLOW"}

    return evaluate
```

--------------------------------

### Install tmux

Source: https://omnigent.ai/docs/interact/terminal

Install the tmux terminal multiplexer, which is required for the Omnigent terminal interface. Use the appropriate package manager for your operating system.

```bash
# macOS
brew install tmux

# Debian / Ubuntu
apt install tmux
```

--------------------------------

### Initiate Debby Brainstorming

Source: https://omnigent.ai/docs/use/builtin-agents/debby

Use this command to start a brainstorming session with Debby, which sends questions to both Claude and GPT.

```bash
omni debbycopy
```

--------------------------------

### Configure Agent Tools

Source: https://omnigent.ai/docs/use/custom-agents

Integrate external tools like MCP servers, Python functions, or sub-agents. This example shows configurations for GitHub MCP and a Python function.

```yaml
tools:
  github:
    type: mcp
    command: uv
    args: [run, python, -m, github_mcp]
  summarize:
    type: function
    callable: my_package.tools.summarize_file
```

--------------------------------

### Configure Agent Policies

Source: https://omnigent.ai/docs/use/custom-agents

Implement declarative guardrails using YAML. This example configures a rate limiting policy to restrict the number of tool calls per session.

```yaml
policies:
  rate_limit:
    type: function
    handler: omnigent.policies.builtins.safety.max_tool_calls_per_session
    factory_params:
      limit: 50
```

--------------------------------

### Configure Agent Harness

Source: https://omnigent.ai/docs/use/custom-agents

Specify the runtime executor for your agent. This example sets the harness type to 'omnigent' and the specific harness to 'claude'.

```yaml
executor:
  type: omnigent
  config:
    harness: claud
```

--------------------------------

### Write a Basic Policy Function

Source: https://omnigent.ai/docs/policies/custom

Define a Python function that accepts a `PolicyEvent` and returns a `PolicyResponse` or `None`. This example denies calls to a 'dangerous_tool'.

```python
from omnigent.policies.schema import PolicyEvent, PolicyResponse

def my_policy(event: PolicyEvent) -> PolicyResponse | None:
    if event["type"] != "tool_call":
        return None
    if event["data"]["name"] == "dangerous_tool":
        return {"result": "DENY", "reason": "Blocked."}
    return {"result": "ALLOW"}
```

--------------------------------

### Configure Agent Model

Source: https://omnigent.ai/docs/use/custom-agents

Select the Large Language Model (LLM) to power the agent's harness. This example uses 'claude-sonnet-4-6'.

```yaml
executor:
  type: omnigent
  config:
    harness: claude
  model: claude-sonnet-4-6
```

--------------------------------

### Register Custom Policy with POLICY_REGISTRY

Source: https://omnigent.ai/docs/policies/custom

Export a `POLICY_REGISTRY` list from your Python module to make custom policies discoverable. This example registers the 'block_domains' factory.

```python
# myorg/policies.py

POLICY_REGISTRY = [
    {
        "handler": "myorg.policies.block_domains",
        "kind": "factory",
        "name": "Block Domains",
        "description": "Block web access to specific domains.",
        "params_schema": {
            "type": "object",
            "properties": {
                "blocked_domains": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "Domains to block"
                }
            },
            "required": ["blocked_domains"]
        }
    }
]
```

--------------------------------

### Server-Wide Policy Declaration (Cost Budget)

Source: https://omnigent.ai/docs/policies/overview

Configure server-wide policies in your server config YAML to apply to all sessions. This example shows cost-related policies with specific thresholds and maximums.

```yaml
policies:
  session_cost_guard:
    type: function
    function:
      path: omnigent.policies.builtins.cost.cost_budget
      arguments:
        ask_thresholds_usd: [1.0]
        max_cost_usd: 5.0
  user_daily_cost_guard:
    type: function
    function:
      path: omnigent.policies.builtins.cost.user_daily_cost_budget
      arguments:
        ask_thresholds_usd: [10.0, 25.0]
        max_cost_usd: 50.0copy
```

--------------------------------

### Launch Debby Agent

Source: https://omnigent.ai/docs

Start the Debby agent, a multi-AI agent that queries Claude and GPT simultaneously. This command also launches a web UI for interaction.

```bash
omni debby
```

--------------------------------

### Filtering Discovered Skills in Agent Configuration

Source: https://omnigent.ai/docs/build/prompts

Demonstrates how to configure an agent's YAML file to control which discovered skills are loaded. This example shows loading specific skills by name.

```yaml
skills:
  - code-review
  - deploy
```

--------------------------------

### Launch Omnigent Agents

Source: https://omnigent.ai/docs/interact/terminal

Launch Omnigent agents from the terminal. You can start pre-built coding agents like Claude or Codex, or run custom agents defined in YAML files or directories.

```bash
omni claude                          # Claude Code
omni codex                           # Codex
omni run agent.yaml                  # custom omnigent
omni run ./my-agent/                 # directory with config.yaml
```

--------------------------------

### Run Claude Code or Codex with Omni CLI

Source: https://omnigent.ai/docs/use/coding-agents

Use the 'omni' command-line interface to quickly start Claude Code or Codex. This bypasses the need for manual YAML configuration.

```bash
omni claude    # Claude Code
omni codex     # Codexcopy
```

--------------------------------

### Register Host with Server

Source: https://omnigent.ai/docs/deploy/overview

Use these commands to register your local machine as a host with the Omnigent server. Authentication may be required.

```bash
omni login <server-url>  // if auth is enabled
omni host <server-url>
```

--------------------------------

### Set System Prompt from File

Source: https://omnigent.ai/docs/build/prompts

Use the `instructions` field to specify a file path for the system prompt. The path is resolved relative to the agent YAML's directory.

```yaml
instructions: prompts/system.md
```

--------------------------------

### Manage Cloud Sandbox Hosts via CLI

Source: https://omnigent.ai/docs/deploy/cloud-sandbox-host

Create and connect to cloud sandbox hosts using the Omnigent CLI, specifying the provider and sandbox ID.

```bash
omni sandbox create --provider modal          # or --provider daytona
omni sandbox connect --provider modal \
  --sandbox-id <id> --server <url>copy
```

--------------------------------

### Minimal OS Sandbox Configuration

Source: https://omnigent.ai/docs/policies/os-sandbox

This snippet shows the smallest useful OS sandbox configuration. It makes the working directory writable and allows network access, letting Omnigent auto-detect the backend.

```yaml
os_env:
  type: caller_process
  cwd: .
  sandbox:
    write_paths: [.]          # cwd is read-only by default; opt it back in
    allow_network: truecopy
```

--------------------------------

### Configure Daytona Cloud Sandbox Host

Source: https://omnigent.ai/docs/deploy/cloud-sandbox-host

Configure the Omnigent server to use Daytona as the cloud sandbox host provider, specifying the image and environment variables to copy.

```yaml
sandbox:
  provider: daytona
  server_url: https://your-server.example.com
  daytona:
    image: docker.io/you/omnigent-host:latest      # optional, official image by default
    env: [OPENAI_API_KEY, ANTHROPIC_API_KEY]        # server env vars to copy into sandboxcopy
```

--------------------------------

### Deploy Omnigent Server to Fly.io

Source: https://omnigent.ai/docs/deploy/overview

Deploy the Omnigent server to Fly.io using the `fly deploy` command. This method uses SQLite on a persistent volume. Ensure your machine has sufficient memory (e.g., 1GB) as the server idles around 275 MB RSS.

```bash
cd deploy/fly
fly deploycopy
```

--------------------------------

### Login and Host Registration

Source: https://omnigent.ai/quickstart/collaborate

Use 'omni login' to authenticate with your deployed Omnigent server and 'omni host' to register your local machine for agent work dispatch.

```bash
omni login https://your-server.up.railway.app
omni host https://your-server.up.railway.appcopy
```

--------------------------------

### Omnigent Config-Level Policy Declaration

Source: https://omnigent.ai/docs/policies/overview

Declare persistent policies in the `policies` block of your Omnigent config YAML. These policies are applied every time the Omnigent starts.

```yaml
policies:
  approve_file_ops:
    type: function
    handler: omnigent.policies.builtins.safety.ask_on_os_tools
  rate_limit:
    type: function
    handler: omnigent.policies.builtins.safety.max_tool_calls_per_session
    factory_params:
      limit: 50copy
```

--------------------------------

### Deploy Omnigent Server with Docker Compose

Source: https://omnigent.ai/docs/deploy/overview

Deploy the Omnigent server and a Postgres database using Docker Compose. Ensure you run the bootstrap script first to generate necessary environment variables.

```bash
cd deploy/docker
./bootstrap.sh          # generates DB password + cookie secret into .env
docker compose up -d    # Omnigent server + Postgrescopy
```

--------------------------------

### Run a Custom Agent

Source: https://omnigent.ai/docs/use/custom-agents

Execute a custom agent by providing the path to its directory containing the `config.yaml` file.

```bash
omni run ./my-agent/              # directory containing config.yaml
```

--------------------------------

### Launch Polly

Source: https://omnigent.ai/docs/use/builtin-agents/polly

Use the 'omni polly' command to launch Polly. It can also be launched by simply typing 'omni' as it is the default agent.

```bash
omni polly
omni          # also launches Polly (it's the default)
```

--------------------------------

### Enable Invites for External Users

Source: https://omnigent.ai/docs/collaborate/auth

Allow external users to sign up by setting the OMNIGENT_OIDC_ALLOW_INVITES environment variable to 1.

```bash
OMNIGENT_OIDC_ALLOW_INVITES=1
```

--------------------------------

### SKILL.md File Structure

Source: https://omnigent.ai/docs/build/prompts

Demonstrates the format of a SKILL.md file, which includes YAML frontmatter for metadata and a markdown body for detailed instructions.

```markdown
---
name: code-review
description: >-
  Review code changes for correctness, tests, security, and
  maintainability. Use when asked to review a PR or diff.
---

# Code review

## Procedure
1. Read the diff carefully.
2. Check for correctness and edge cases.
3. Verify tests cover the changes.
4. Flag security concerns.
5. Summarize findings as blocking / non-blocking / suggestions.

## What to look for
- Off-by-one errors
- Missing error handling
- Untested branches
...
```

--------------------------------

### Configure Modal Cloud Sandbox Host

Source: https://omnigent.ai/docs/deploy/cloud-sandbox-host

Configure the Omnigent server to use Modal as the cloud sandbox host provider, specifying the image and secrets to use.

```yaml
sandbox:
  provider: modal
  server_url: https://your-server.example.com
  modal:
    image: ghcr.io/omnigent-ai/omnigent-host:latest  # optional, official image by default
    secrets: [omnigent-llm]                        # Modal secrets with LLM API keyscopy
```

--------------------------------

### Postgres Database URL Configuration

Source: https://omnigent.ai/docs/deploy/database

Use this format to configure the DATABASE_URL for a Postgres instance. This is the recommended option for production environments and multi-instance deployments.

```bash
DATABASE_URL=postgresql://user:pass@host:5432/omnigentcopy
```

--------------------------------

### Create a Custom Agent with a Coding Agent

Source: https://omnigent.ai/docs/use/custom-agents

Ask your coding agent to build a custom agent by describing its requirements in natural language. The agent will create and register the YAML configuration file.

```natural language
You: Build me a documentation reviewer agent. It should use Claude as
     the model, have access to the file system and GitHub, and follow
     our style guide at docs/STYLE.md.

Agent: Created "docs-reviewer" agent. Opening a new session with it now.
       You can select it from the session dropdown anytime.
```

--------------------------------

### Configure Daytona API Key

Source: https://omnigent.ai/docs/deploy/cloud-sandbox-host

Set the Daytona API key as an environment variable on the server to authenticate with the Daytona platform.

```bash
export DAYTONA_API_KEY=dtn_…copy
```

--------------------------------

### SQLite Database URL Configuration

Source: https://omnigent.ai/docs/deploy/database

Use this format to configure the DATABASE_URL for a SQLite instance. This is suitable for demos and single-instance deployments where zero dependencies are preferred.

```bash
DATABASE_URL=sqlite:////data/artifacts/chat.dbcopy
```

--------------------------------

### Login to Claude Pro/Max

Source: https://omnigent.ai/docs/build/models

Authenticate your CLI session for using Claude Pro/Max models.

```bash
claude auth login    # for Claude Pro/Max
```

--------------------------------

### Login to ChatGPT

Source: https://omnigent.ai/docs/build/models

Authenticate your CLI session for using ChatGPT Plus/Pro models.

```bash
codex login          # for ChatGPTcopy
```

--------------------------------

### Runtime Harness Override

Source: https://omnigent.ai/docs/build/harnesses

This command demonstrates how to override the harness setting at runtime using the 'omni run' command.

```bash
omni run agent.yaml --harness codexcopy
```

--------------------------------

### Configure Agent Prompt

Source: https://omnigent.ai/docs/use/custom-agents

Define the system prompt for the agent. It can be set inline as a string or by referencing a file.

```yaml
prompt: You are a concise coding assistant.

# Or from a file:
instructions: AGENTS.md
```

--------------------------------

### Set System Prompt with Inline Text

Source: https://omnigent.ai/docs/build/prompts

Define the agent's system prompt using either the `prompt` or `instructions` field with inline text. If both are set, `instructions` takes precedence.

```yaml
prompt: You are a concise coding assistant.
```

```yaml
instructions: You are a concise coding assistant.
```

--------------------------------

### Configure OIDC for SSO

Source: https://omnigent.ai/docs/collaborate/auth

Configure Single Sign-On (SSO) using OpenID Connect (OIDC) by setting OIDC issuer, domain, client ID, and client secret in the Docker environment file.

```bash
OMNIGENT_OIDC_ISSUER=https://accounts.google.com
OMNIGENT_DOMAIN=agents.yourcompany.com
OMNIGENT_OIDC_CLIENT_ID=...
OMNIGENT_OIDC_CLIENT_SECRET=...
```

--------------------------------

### Skill Directory Structure

Source: https://omnigent.ai/docs/build/prompts

Shows the typical file and directory structure for a single skill, including the mandatory SKILL.md file and optional resource/script directories.

```directory structure
skills/
  my-skill/
    SKILL.md
    references/      # optional resource files
      style-guide.md
    scripts/         # optional scripts
    assets/          # optional assets
```

--------------------------------

### Declare Local MCP Server

Source: https://omnigent.ai/docs/build/tools

Configure a local MCP server using the 'command' transport. Environment variables are expanded at runtime.

```yaml
tools:
  my-server:
    type: mcp
    command: node
    args: [dist/server.js]
    env:
      API_KEY: ${MY_API_KEY}          # env vars expanded at runtimecopy
```

--------------------------------

### Configure Domain Allowlist and Admins

Source: https://omnigent.ai/docs/collaborate/auth

Configure access control by specifying allowed email domains and administrator email addresses in the server configuration file.

```yaml
allowed_domains: [yourcompany.com]
admins: [you@yourcompany.com]
```

--------------------------------

### Enable Built-in Accounts for Non-Docker

Source: https://omnigent.ai/docs/collaborate/auth

Enable built-in accounts for non-Docker deployments by setting the OMNIGENT_AUTH_ENABLED environment variable.

```bash
OMNIGENT_AUTH_ENABLED=1 omni server start
```

--------------------------------

### Define and Reuse OS Sandbox Policy with YAML Anchor

Source: https://omnigent.ai/docs/policies/os-sandbox

Declare a sandbox policy once and reuse it across different configurations using YAML anchors for consistency.

```yaml
os_env:
  type: caller_process
  cwd: .
  sandbox: &shared
    write_paths: [.]
    read_paths: [~/.gitconfig, ~/.ssh]
    allow_network: true

terminals:
  zsh:
    command: zsh
    os_env:
      type: caller_process
      cwd: .
      sandbox: *shared              # same policy as sys_os_* toolscopy
```

--------------------------------

### Registering Custom Policies in Server Configuration

Source: https://omnigent.ai/docs/policies/overview

Add custom policy modules to your server configuration to make them available alongside built-in policies. Ensure the path points to your Python policy files.

```yaml
# server config (config.yaml)
policy_modules:
  - myorg.policiescopy
```

--------------------------------

### Default Harness Configuration

Source: https://omnigent.ai/docs/build/harnesses

This snippet shows the default configuration for specifying the harness in a YAML file.

```yaml
executor:
  harness: claudecopy
```

--------------------------------

### Configure Filesystem Access in Sandbox

Source: https://omnigent.ai/docs/policies/os-sandbox

Define read-only and writable paths, as well as specific files that can be written to within the sandbox. Hidden dotfiles are masked by default unless explicitly allowed.

```yaml
sandbox:
  read_paths: [~/.gitconfig, ~/.ssh]        # read-only access outside cwd
  write_paths: [.]                          # writable directories
  write_files: [~/.ssh/known_hosts]         # individual writable files
  cwd_allow_hidden: [.venv, .git, .env]     # dotfiles to allow (rest are masked)
```

--------------------------------

### Inherit Parent Environment and Sandbox

Source: https://omnigent.ai/docs/policies/os-sandbox

Use `os_env: inherit` to propagate the parent's full environment, including its sandbox, to child agents or terminals.

```yaml
# Parent config.yaml
tools:
  agents:
    - researcher
    - coder

# agents/researcher/config.yaml
os_env:
  sandbox:
    write_paths: [./research]
    allow_network: true

# agents/coder/config.yaml
os_env:
  sandbox:
    write_paths: [./src]
    allow_network: falsecopy
```

--------------------------------

### Configure Network Egress Rules in Sandbox

Source: https://omnigent.ai/docs/policies/os-sandbox

Enable network access and define specific egress rules for HTTP(S) traffic using a MITM proxy. Private IP destinations are blocked by default.

```yaml
sandbox:
  allow_network: true                       # basic on/off
  egress_rules:                             # optional HTTP(S) allow-list
    - "GET api.github.com/repos/myorg/**"   # GET only, one org
    - "* pypi.org/**"                       # any method
    - "* *.github.com/**"                   # wildcard subdomain
```

--------------------------------

### Agent Directory Structure with Skills

Source: https://omnigent.ai/docs/build/prompts

Illustrates the directory structure of an agent, showing where bundled skills are located within the agent's 'skills/' directory.

```directory structure
my-agent/
  config.yaml
  skills/
    code-review/
      SKILL.md
    deploy/
      SKILL.md
```

--------------------------------

### Configure Databricks Model with Auth

Source: https://omnigent.ai/docs/build/models

Specify a Databricks model and authentication profile in the agent YAML.

```yaml
executor:
  harness: claude-sdk
  model: databricks-claude-sonnet-4-6
  auth:
    type: databricks
    profile: <your-profile>copy
```

--------------------------------

### MCP Server Authentication with Profile

Source: https://omnigent.ai/docs/build/tools

Authenticate a custom MCP server by resolving an OAuth token from a local configuration file using the 'profile' option.

```yaml
tools:
  internal-api:
    type: mcp
    url: https://my-workspace.databricks.com/mcp
    auth:
      profile: my-profilecopy
```

--------------------------------

### Combine Multiple Tool Types

Source: https://omnigent.ai/docs/build/tools

An agent can utilize a mix of different tool types, including MCP servers, Python functions, and sub-agents, all defined within a single flat 'tools' map.

```yaml
tools:
  github:
    type: mcp
    command: uv
    args: [run, python, -m, my_package.github_mcp]

  summarize_file:
    type: function
    callable: my_package.tools.summarize_file

  reviewer:
    type: agent
    config: agents/reviewer.yamlcopy
```

--------------------------------

### Attach to Omnigent Session (Terminal)

Source: https://omnigent.ai/docs/collaborate

Use this command to attach a teammate to your running Omnigent session from the terminal. This allows them to co-drive the session.

```bash
omni attach <session_id>
```

--------------------------------

### Resume a Session

Source: https://omnigent.ai/docs/interact/terminal

Resume a previous Omnigent session using its unique conversation ID. This allows you to pick up where you left off, maintaining the full conversation history and context.

```bash
omni resume <conversation_id>
```

--------------------------------

### Migrate Built-in Accounts to OIDC

Source: https://omnigent.ai/docs/collaborate/auth

Migrate existing users from built-in accounts to OIDC, preserving sessions and admin rights. Use `--commit` to apply changes, or omit it for a dry run.

```bash
omni debug migrate-accounts-to-oidc <database-url> --domain yourcompany.com --commit
```

--------------------------------

### Accessing Omnigent on Same Network

Source: https://omnigent.ai/docs/interact/mobile

To access the Omnigent server from your phone when on the same network, use your machine's local IP address instead of 'localhost'. Ensure your phone is connected to the same Wi-Fi network.

```text
http://192.168.x.x:6767
```

--------------------------------

### Add Policy Module to Server Configuration

Source: https://omnigent.ai/docs/policies/custom

Include your custom policy module in the `policy_modules` list within your server's configuration file (e.g., `config.yaml`).

```yaml
# config.yaml
policy_modules:
  - myorg.policies
```

--------------------------------

### Expose Python Function as Tool

Source: https://omnigent.ai/docs/build/tools

Expose a Python callable as a tool by referencing its fully qualified import path. The 'parameters' schema is optional and can be auto-generated from type annotations.

```yaml
tools:
  summarize_file:
    type: function
    description: Summarize a local text file.
    callable: my_package.tools.summarize_file
    parameters:
      type: object
      properties:
        path:
          type: string
      required: [path]copy
```

--------------------------------

### Override Model at Runtime

Source: https://omnigent.ai/docs/build/models

Change the model used by the agent at runtime without modifying the agent's YAML file.

```bash
omni run agent.yaml --model claude-sonnet-4-6copy
```

--------------------------------

### Declare Remote MCP Server

Source: https://omnigent.ai/docs/build/tools

Configure a remote MCP server using the 'url' transport. HTTP headers can be used for authentication, with environment variables expanded at runtime.

```yaml
tools:
  docs-api:
    type: mcp
    url: https://example.com/mcp
    headers:
      Authorization: "Bearer ${API_TOKEN}"   # env vars expanded at runtimecopy
```

--------------------------------

### Reference External Sub-agent Config

Source: https://omnigent.ai/docs/build/tools

Declare a sub-agent tool by pointing to a separate YAML file containing its specification. This is useful for complex or shared agent configurations.

```yaml
tools:
  reviewer:
    type: agent
    description: Review proposed code changes.
    config: agents/reviewer.yamlcopy
```

--------------------------------

### Fork Omnigent Session (Terminal)

Source: https://omnigent.ai/docs/collaborate

Use this command to fork an existing Omnigent session from the terminal. This creates an independent copy of the conversation history up to the fork point.

```bash
omni run --fork <session_id>
```

--------------------------------

### Declare Model in Agent YAML

Source: https://omnigent.ai/docs/build/models

Specify the model to be used by the agent in its YAML configuration file.

```yaml
executor:
  harness: claude-sdk
  model: claude-sonnet-4-6copy
```

--------------------------------

### Inherit Parent Tool in Sub-agent

Source: https://omnigent.ai/docs/build/tools

Allow a sub-agent to inherit a specific tool from its parent agent using the 'inherit' keyword. This avoids duplicating tool definitions.

```yaml
tools:
  researcher:
    type: agent
    prompt: Research and summarize.
    tools:
      word_count: inherit    # gets word_count from parentcopy
```

--------------------------------

### Restart Docker Compose

Source: https://omnigent.ai/docs/collaborate/auth

Restart Docker Compose services to apply changes made to the environment variables.

```bash
docker compose up -d
```

--------------------------------

### Configure Environment Variable Passthrough in Sandbox

Source: https://omnigent.ai/docs/policies/os-sandbox

Specify environment variables that should be passed through to the sandbox agent. By default, only essential variables are included.

```yaml
sandbox:
  env_passthrough: [GH_TOKEN, AWS_PROFILE]  # only these vars reach the agent
```

--------------------------------

### Define Inline Sub-agent Tool

Source: https://omnigent.ai/docs/build/tools

Define a sub-agent directly within the parent agent's 'tools' block. This includes its prompt, executor, and session management settings.

```yaml
tools:
  reviewer:
    type: agent
    description: Review proposed code changes.
    prompt: |
      You are a careful code reviewer. Focus on correctness,
      tests, security, and maintainability.
    executor:
      harness: claude-sdk
      model: claude-sonnet-4-6
    os_env: inherit
    pass_history: true
    max_sessions: 2copy
```