What makes kami-conflict-detection notable?

1.1K downloads. Trust evidence available

How should kami-conflict-detection be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

kami-conflict-detection

Detect physical conflicts (fighting, shoving, scuffling) between 2+ people from one or many RTSP camera streams concurrently. Continuous mode: a single Pytho... Skill: kami-conflict-detection Owner: 13681882136 Summary: Detect physical conflicts (fighting, shoving, scuffling) between 2+ people from one or many RTSP camera streams concurrently. Continuous mode: a single Pytho... Tags: latest:2.0.4 Version history: v2.0.4 | 2026-06-09T05:56:07.493Z | user add alert img v2.0.3 | 2026-05-29T03:10:32.629Z | user add muitl cma v2.0.2 | 2026-05-28T02:23:01.145Z | user remove env v2

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

2.0.4

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 2.0.4release · observed Jun 9, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s170wja1qf8kmkzj5brvhsj1r185a522:kami-conflict-detection

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-13681882136-kami-conflict-detection/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

143,413 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: kami-conflict-detection
description: |
Detect physical conflicts (fighting, shoving, scuffling) between 2+ people from one or many
RTSP camera streams concurrently. Continuous mode: a single Python process monitors every
configured camera in parallel, pushes a per-camera alert (stdout / inbox file / Feishu /
Discord / Telegram) on each detected event, and keeps running — it does NOT exit on
detection.
version: 2.0.4
author: kami-smarthome
tags:
- smart-home
- conflict-detection
- fight-detection
- violence-detection
- yolo
- rtsp
- surveillance
- security
- edge-ai
- multi-camera
- openclaw
triggers:
- detect fighting
- detect conflict
- detect physical conflict
- check for fighting
- is anyone fighting
- detect scuffle
- detect shoving
- monitor for fights
- start conflict monitoring
- begin violence detection
metadata:
openclaw:
requires:
bins:
- python3.10
hardware:
cpu: "4+ cores (x86_64 / ARM64)"
memory: "8 GB+"
storage: "10 GB+"
gpu: "optional (speeds up ONNX inference)"
network:
- "RTSP camera access (LAN)"
- "Internet (KamiClaw API)"
devices:
- "RTSP IP camera"
emoji: "🥊"
---

# Kami Conflict Detection

Detect physical conflicts (fighting, shoving, scuffling) between 2+ people from one or many RTSP camera streams concurrently. Continuous mode — the process never exits on detection; every confirmed event is pushed as an alert tagged with the originating camera, then monitoring resumes.

## Privacy Policy

For privacy policy details, see: <https://kamiclaw-skill.kamihome.com/privacy>

## How It Works

1. **YOLO pre-filter** — lightweight person detection counts people in each frame (must be ≥ `min_persons`, default 2).
2. **Multi-frame collection** — collects N frames with a configurable time gap.
3. **LLM conflict analysis** — frames are sent to the Kami detection API for violence/conflict judgment.
4. **Continuous alerting** — on a confirmed conflict, the worker saves a per-camera video clip, pushes an alert with `camera = <camera_name>` to every configured channel, and **immediately resumes monitoring**. The process keeps running until the user stops it (Ctrl+C / OpenClaw shutdown).

> Multi-camera: every entry in `config.json -> cameras[]` runs in its own worker thread inside the same process. The YOLO ONNX session, the conflict analyzer and all push channels are shared once across cameras. Push channels are **shared** — no per-camera webhook split. Stranger / clip / log lines are namespaced by camera name.

## When to Use

- Monitor one or many camera feeds for physical fights or scuffles
- Detect shoving, pushing, or violent behavior between people
- Run conflict detection on a local video file for testing
- Set up automated surveillance alerts for physical altercations

## Installation

```bash
bash

README.md

# Kami Conflict Detection

Real-time multi-camera physical conflict (fighting, shoving, scuffling) detection for RTSP camera streams or local video files. Uses YOLO for person pre-filtering and a remote multimodal LLM API for conflict analysis.

**Multi-camera capable.** A single process can monitor an arbitrary number of RTSP cameras concurrently (e.g. `living_room` + `office_door` + …). The YOLO ONNX session and conflict analyzer are loaded **once and shared** across all cameras; each camera owns an independent frame grabber, worker thread and snapshot directory. Push channels (Feishu / Discord / Telegram) are shared — every camera uses the same webhooks. The process keeps running across detections — it does NOT exit on event.

## How It Works

For each configured camera, a dedicated worker thread polls the stream, uses YOLO to count persons in each frame, and when 2+ people are detected, collects multiple frames and sends them to the Kami detection API for conflict analysis. When a conflict is confirmed, the worker saves a per-camera video clip covering the moments before and after the incident, prints an alert JSON line tagged with the camera name to stdout, pushes the alert to every configured channel, and **immediately resumes monitoring**. The process keeps running until the user stops it (Ctrl+C / OpenClaw shutdown).

```
For each camera (parallel worker thread):
Read stream → YOLO counts persons → 2+ people? → Collect frames → LLM analysis
↓
Conflict? → save per-camera clip
→ push alert (stdout / inbox / Feishu / Discord / Telegram)
→ resume monitoring (no exit)
```

## Quick Start

```bash
# 1. Install dependencies
bash setup.sh

# 2. Configure cameras and API key in config.json (recommended), then run:
.venv/bin/python conflict_detector_last.py

# Or for a one-off single-camera run via CLI override:
.venv/bin/python conflict_detector_last.py \
--rtsp_url rtsp://192.168.1.100/live/stream1 \
--camera_name living_room \
--kami_api_key YOUR-API-KEY
```

## Installation

```bash
bash setup.sh
```

No `sudo` required. The script will:
- Auto-bootstrap **Python 3.10** in user space (via [uv](https://github.com/astral-sh/uv)) — no system-level package manager needed
- Create a `.venv/` virtual environment
- Install all pip dependencies (`onnxruntime`, `opencv-python-headless`, `numpy`, `requests`)
- Auto-download a pre-exported YOLO ONNX bundle from `https://publicfiles.xiaoyi.com/kami-conflict-detection-model.zip` (extracted to a temp folder, then `.onnx` is moved next to the script and the temp folder is deleted) — **no `.pt` conversion / no `ultralytics` install**.
- Create `alerts/` output directory

## API Key

This skill requires a Kami API key for the conflict a

_meta.json

{
  "ownerId": "kn7e9156e1awf00v1sas2wkdfd85a4zh",
  "slug": "kami-conflict-detection",
  "version": "2.0.4",
  "publishedAt": 1780984567493
}

skill-card.md

## Description:

Detects physical conflicts such as fighting, shoving, and scuffling from one or more RTSP camera streams or local video files.

This skill is ready for commercial/non-commercial use.

## Publisher:

[13681882136](https://clawhub.ai/user/13681882136)

### License/Terms of Use:

MIT-0

## Use Case:

Developers, facility operators, and security teams use this skill to monitor RTSP cameras or test video files for possible physical altercations and route alerts to local output or configured messaging channels.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Selected camera frames leave the local environment for Kami conflict analysis.

Mitigation: Use the skill only with approved cameras and environments, review the privacy policy, and confirm that surveillance footage may be sent to the Kami service.

Risk: Snapshots and alert details may be sent to configured third-party channels or public image hosting.

Mitigation: Use private, approved messaging channels and avoid the Feishu sm.ms fallback unless public image hosting is acceptable.

Risk: Configuration and logs can contain sensitive camera URLs, API keys, webhooks, or alert details.

Mitigation: Protect config.json and logs with local access controls, avoid committing them, and use dedicated low-privilege camera credentials.

Risk: Setup downloads dependencies and a model artifact during installation or first run.

Mitigation: Review and pin setup dependencies and model artifacts before deployment in controlled or regulated environments.

## Reference(s):

- [ClawHub skill page](https://clawhub.ai/13681882136/skills/kami-conflict-detection)
- [KamiClaw service](https://kamiclaw-skill.kamihome.com)
- [Kami conflict detection model bundle](https://publicfiles.xiaoyi.com/kami-conflict-detection-model.zip)
- [uv Python package manager](https://github.com/astral-sh/uv)

## Skill Output:

**Output Type(s):** [guidance, shell commands, configuration, JSON, files]

**Output Format:** [Markdown guidance with shell commands and JSON alert records; the detector also saves MP4 clips and JPEG snapshots.]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Requires configured camera sources and a Kami API key; alerts can be emitted to stdout, an inbox file, Feishu, Discord, or Telegram.]

## Skill Version(s):

2.0.4 (source: frontmatter and release evidence)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

config.json

{
  "cameras": [
    {
      "name": "",
      "rtsp_url": ""
    }
  ],
  "kami_api_key": "",
  "feishu_webhook": "",
  "feishu_secret": "",
  "feishu_app_id": "",
  "feishu_app_secret": "",
  "discord_webhook": "",
  "telegram_bot_token": "",
  "telegram_chat_id": ""
}

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.