Use Cases

Robotics

OmniLink was born from robotics. The platform’s command engine, ToolRunner, and HTTP bridge were all designed with autonomous robot control in mind.

What You Can Build

• Natural-language mission planning (“Patrol the warehouse, check aisles 3 through 7, report anomalies”)
• Autonomous navigation with waypoint management
• Sensor-fusion pipelines that feed data to the AI for decision-making
• Multi-robot coordination through shared HTTP endpoints
• Emergency stop and safety overrides via command priorities

Architecture

# Robot control flow
#
# User (voice/text)
#   └──▶ OmniLink Cloud (AI reasoning)
#          └──▶ HTTP POST /command
#                 └──▶ Local OmniLinkEngine (on robot)
#                        ├── Parse command
#                        ├── Execute motion controller
#                        ├── Read LIDAR / camera
#                        └──▶ HTTP GET /feedback
#                               └──▶ OmniLink Cloud (analysis)

Example: TurtleBot3 Controller

from omnilink import OmniLinkEngine

engine = OmniLinkEngine()

@engine.command("move [direction:str] [distance:float] meters")
def move(direction: str, distance: float):
    """Drive the robot in a direction."""
    velocities = {
        "forward":  ( 0.2, 0.0),
        "backward": (-0.2, 0.0),
        "left":     ( 0.0,  0.5),
        "right":    ( 0.0, -0.5),
    }
    linear, angular = velocities.get(direction, (0.0, 0.0))
    duration = distance / abs(linear) if linear else distance / abs(angular)
    robot.send_velocity(linear, angular, duration)
    return f"Moving {direction} for {distance}m"

@engine.command("scan area")
def scan():
    """Perform a 360-degree LIDAR scan."""
    readings = robot.get_lidar_scan()
    obstacles = [r for r in readings if r < 0.5]
    return f"Scan complete. {len(obstacles)} nearby obstacles detected."

@engine.command("go to waypoint [name:str]")
def goto_waypoint(name: str):
    """Navigate to a named waypoint."""
    waypoints = {"charging_station": (2.0, 3.5), "entrance": (0.0, 0.0)}
    if name not in waypoints:
        return f"Unknown waypoint: {name}"
    x, y = waypoints[name]
    robot.navigate_to(x, y)
    return f"Navigating to {name} at ({x}, {y})"

Smart Home

Turn any home into a voice- and text-controlled environment. OmniLink agents manage lights, locks, thermostats, and appliances through structured commands and HTTP messaging.

What You Can Build

• Voice-controlled lighting (“Dim the living room to 40%”)
• Door lock management with access logging
• Thermostat scheduling and override
• Routine automation (“Good night” turns off lights, locks doors, sets temperature)
• Energy monitoring and optimization suggestions

Example: Home Controller

from omnilink import OmniLinkEngine

engine = OmniLinkEngine()

@engine.command("turn [state:str] the [device:str]")
def toggle_device(state: str, device: str):
    """Turn a device on or off."""
    requests.post(f"http://localhost:8080/device/{device}", json={"state": state})
    return f"{device} turned {state}"

@engine.command("set [device:str] brightness to [level:int] percent")
def set_brightness(device: str, level: int):
    """Adjust brightness of a light."""
    level = max(0, min(100, level))
    requests.post(f"http://localhost:8080/device/{device}/brightness", json={"level": level})
    return f"{device} brightness set to {level}%"

@engine.command("set temperature to [temp:int] degrees")
def set_thermostat(temp: int):
    """Set the thermostat target temperature."""
    if temp < 60 or temp > 85:
        return f"Temperature {temp}F is outside the safe range (60-85)."
    requests.post("http://localhost:8080/device/thermostat", json={"target": temp})
    return f"Thermostat set to {temp}F"

@engine.command("lock the [door:str] door")
def lock_door(door: str):
    """Lock a specific door."""
    requests.post(f"http://localhost:8080/device/locks/{door}", json={"state": "locked"})
    return f"{door} door locked"

@engine.command("run routine [name:str]")
def run_routine(name: str):
    """Execute a named automation routine."""
    routines = {
        "good night": [
            ("device/lights/all", {"state": "off"}),
            ("device/locks/front", {"state": "locked"}),
            ("device/locks/back", {"state": "locked"}),
            ("device/thermostat", {"target": 68}),
        ],
        "good morning": [
            ("device/lights/kitchen", {"state": "on"}),
            ("device/thermostat", {"target": 72}),
        ],
    }
    if name not in routines:
        return f"Unknown routine: {name}"
    for endpoint, payload in routines[name]:
        requests.post(f"http://localhost:8080/{endpoint}", json=payload)
    return f"Routine '{name}' executed ({len(routines[name])} actions)"

Industrial Automation

In industrial settings, OmniLink acts as an intelligent gateway between human operators and factory-floor equipment. The HTTP bridge integrates natively with industrial IoT protocols.

What You Can Build

• Natural-language control of PLCs and actuators
• Sensor monitoring with AI-driven anomaly detection
• Predictive maintenance alerts based on telemetry patterns
• Shift-change reports generated automatically from production data
• Safety interlock verification before hazardous operations

Architecture

# Industrial deployment
#
#  Operator tablet / SCADA
#    └──▶ OmniLink REST API
#           └──▶ g2-engine (GPT for complex reasoning)
#                  └──▶ ToolRunner on edge gateway
#                         ├── Read OPC-UA sensors
#                         ├── Issue Modbus commands
#                         ├── Log to historian
#                         └── Report to cloud

Example: Sensor Monitor

from omnilink import OmniLinkEngine

engine = OmniLinkEngine()

@engine.command("read sensor [sensor_id:str]")
def read_sensor(sensor_id: str):
    """Read the current value of an industrial sensor."""
    value = gateway.read_register(sensor_id)
    unit = gateway.get_unit(sensor_id)
    threshold = gateway.get_threshold(sensor_id)
    status = "NORMAL" if value < threshold else "WARNING"
    return f"Sensor {sensor_id}: {value} {unit} [{status}]"

@engine.command("emergency stop line [line_id:int]")
def emergency_stop(line_id: int):
    """Trigger an emergency stop on a production line."""
    gateway.send_command(f"line_{line_id}", "E_STOP")
    gateway.log_event("E_STOP", line_id, operator="ai_agent")
    return f"Emergency stop triggered on line {line_id}"

@engine.command("generate report for [shift:str] shift")
def shift_report(shift: str):
    """Generate a production summary for a shift."""
    data = gateway.get_shift_data(shift)
    return (
        f"Shift: {shift}\n"
        f"Units produced: {data['units']}\n"
        f"Defect rate: {data['defect_rate']}%\n"
        f"Downtime: {data['downtime_min']} minutes\n"
        f"Alerts: {data['alert_count']}"
    )

Customer Support

Build AI support agents that go beyond simple FAQ bots. OmniLink’s knowledge integration and memory management let you create agents that understand your product deeply and remember customer context across sessions.

What You Can Build

• Multi-turn support conversations with session memory
• Knowledge-grounded answers from product documentation
• Ticket escalation based on sentiment or complexity
• Multi-language support via the translation API
• Voice-based support with STT/TTS integration

Example: Support Agent Setup

from omnilink import OmniLinkClient

client = OmniLinkClient(
    api_key="omk_your_key_here",
    base_url="https://www.omnilink-agents.com",
)

# Send a support question — knowledge base is searched automatically
response = client.chat(
    message="How do I reset my device to factory settings?",
    engine="g4-engine",  # Claude for precise instruction following
    profile="support-agent",
    include_knowledge=True,
    include_memory=True,
)

print(response.text)
# "To reset your device to factory settings, follow these steps:
#  1. Hold the power button for 10 seconds...
#  (sourced from your uploaded product manual)"

# Save customer context for future sessions
client.set_memory(
    key="customer_issue_history",
    value="Device reset requested on 2026-03-24",
    category="support_context",
)

Game AI

OmniLink’s ToolRunner turns any game into an AI playground. The cloud AI observes game state, decides on actions, and the local runtime executes them — all at the cost of just 2 credits per session.

What You Can Build

• Autonomous Tetris, Pac-Man, or Snake players
• Strategy game advisors that analyze board state
• NPC behavior engines for custom games
• Speedrun optimization agents
• Game testing bots that explore edge cases

Example: Tetris ToolRunner

from omnilink import ToolRunner

class TetrisRunner(ToolRunner):
    """AI-controlled Tetris player using ToolRunner lifecycle."""

    def get_state(self) -> dict:
        """Poll the current game state."""
        return {
            "board": self.game.get_board_matrix(),
            "current_piece": self.game.current_piece.shape,
            "next_piece": self.game.next_piece.shape,
            "score": self.game.score,
            "lines_cleared": self.game.lines,
            "level": self.game.level,
        }

    def execute_action(self, action: str) -> str:
        """Execute an action decided by the cloud AI."""
        actions = {
            "move_left": self.game.move_left,
            "move_right": self.game.move_right,
            "rotate": self.game.rotate,
            "drop": self.game.hard_drop,
            "soft_drop": self.game.soft_drop,
        }
        if action in actions:
            actions[action]()
            return f"Executed: {action}"
        return f"Unknown action: {action}"

    def is_complete(self) -> bool:
        """Check if the game is over."""
        return self.game.is_game_over()

runner = TetrisRunner(omni_key="omk_your_key_here", engine="g1-engine")
runner.start()  # 1 credit to kick off, 1 credit for final analysis

IoT Device Management

OmniLink’s HTTP bridge makes it a natural fit for Internet of Things deployments. Manage fleets of devices with natural-language commands routed through the agent server.

What You Can Build

• Fleet-wide firmware updates triggered by command
• Device health monitoring with AI-driven diagnostics
• Geofence-based automation for asset tracking
• Environmental monitoring (temperature, humidity, air quality)
• Power management and duty-cycle optimization

Example: HTTP Device Fleet

from omnilink import OmniLinkEngine, OmniLinkHTTPBridge
import requests

engine = OmniLinkEngine()

@engine.command("ping device [device_id:str]")
def ping_device(device_id: str):
    """Check if a device is online."""
    try:
        response = requests.get(f"http://fleet-gateway:8080/device/{device_id}/ping", timeout=5.0)
        data = response.json()
        return f"Device {device_id} is online (latency: {data['latency_ms']}ms)"
    except requests.Timeout:
        return f"Device {device_id} did not respond within 5 seconds"

@engine.command("update firmware on [device_id:str] to version [version:str]")
def update_firmware(device_id: str, version: str):
    """Push a firmware update to a specific device."""
    payload = {"version": version, "url": f"https://firmware.example.com/{version}.bin"}
    requests.post(f"http://fleet-gateway:8080/device/{device_id}/ota", json=payload)
    return f"OTA update v{version} sent to {device_id}"

@engine.command("get telemetry from [device_id:str]")
def get_telemetry(device_id: str):
    """Retrieve the latest telemetry data from a device."""
    try:
        response = requests.get(f"http://fleet-gateway:8080/device/{device_id}/telemetry", timeout=10.0)
        data = response.json()
        return f"Telemetry: temp={data['temperature']}C, humidity={data['humidity']}%, battery={data['battery']}%"
    except requests.Timeout:
        return f"No telemetry received from {device_id}"

# Start the HTTP bridge
bridge = OmniLinkHTTPBridge(engine=engine, host="0.0.0.0", port=8080)
bridge.start()

Education

Build tutoring agents that combine conversational AI with knowledge-grounded answers. Upload course materials, textbooks, and lecture notes to create an agent that helps students learn.

What You Can Build

• Subject-specific tutoring agents (math, science, programming)
• Adaptive quiz generators that adjust difficulty based on performance
• Homework assistants that explain concepts rather than giving direct answers
• Language learning agents with STT/TTS for pronunciation practice
• Research assistants that search across uploaded papers and notes

Example: Tutor Agent Configuration

from omnilink import OmniLinkClient

client = OmniLinkClient(omni_key="omk_your_key_here")

# Create a tutoring profile
client.create_profile(
    name="PhysicsTutor",
    persona="A patient and encouraging physics tutor for undergraduate students.",
    system_instructions="""
You are a physics tutor. Your rules:
1. Never give direct answers to homework problems.
2. Guide students through the problem-solving process step by step.
3. Use analogies and real-world examples to explain concepts.
4. When referencing formulas, explain what each variable represents.
5. If a student is struggling, break the problem into smaller parts.
6. Celebrate progress and encourage persistence.
""",
    engine="g4-engine"  # Claude for nuanced instruction following
)

# Upload course materials to the knowledge base
client.knowledge.upload("physics_101_textbook.pdf")
client.knowledge.upload("lecture_notes_week1_to_12.pdf")
client.knowledge.upload("formula_sheet.pdf")

# Student asks a question
response = client.chat(
    message="I don't understand why a ball thrown upward slows down. Isn't there a force pushing it up?",
    profile="PhysicsTutor",
    include_knowledge=True,
)
print(response.text)
# The tutor guides the student through Newton's laws
# and the concept of gravity, referencing the uploaded textbook

Choosing the Right Pattern

Each use case maps to a specific OmniLink integration pattern. Use this table to find the best starting point for your project:

Next Steps

Ready to start building? Head to the Quickstart guide to install the library and run your first agent. For a deeper understanding of how the system works under the hood, see the Architecture page.