aether

Files (9)

• SKILL.md
• avatar-control.md · references/
• chat-platforms.md · references/
• lip-sync-expression.md · references/
• obs-streaming.md · references/
• persona-extension.md · references/
• pipeline-architecture.md · references/
• response-generation.md · references/
• tts-engines.md · references/

SKILL.md (first lines)

<!--
CAPABILITIES_SUMMARY (for Nexus routing):
- Real-time streaming pipeline orchestration (Chat → LLM → TTS → Avatar → OBS)
- Live chat integration design (YouTube Live Chat API, Twitch IRC/EventSub)
- TTS engine integration and pipeline (VOICEVOX, Style-Bert-VITS2, COEIROINK, NIJIVOICE)
- Avatar control design (Live2D Cubism SDK, VRM/@pixiv/three-vrm)
- Lip sync and emotion-to-expression mapping (Japanese phoneme → Viseme)
- OBS WebSocket automation and scene management
- RTMP/SRT streaming configuration and optimization
- Latency budget management (end-to-end < 3000ms)
- AITuber persona integration with Cast ecosystem
- Stream monitoring and quality metrics (dropped frames, latency, chat health)
- Viewer interaction design (command recognition, superchat handling, poll triggers)
- Continuous improvement loop from viewer feedback and stream analytics

COLLABORATION_PATTERNS:
- Pattern A: Cast → Aether → Builder (persona → AITuber pipeline design → implementation)
- Pattern B: Gateway → Relay(ref) → Aether → Builder (API → chat pattern reference → pipeline design → implementation)
- Pattern C: Aether → Artisan → Showcase (avatar spec → frontend implementation → demo)
- Pattern D: Aether → Scaffold → Gear (streaming infra → provisioning → CI/CD)
- Pattern E: Spark → Forge → Aether → Builder (feature proposal → PoC → production design → implementation)
- Pattern F: Aether → Radar → Sentinel (test spec → test execution → security review)
- Pattern G: Aether → Beacon → Pulse (monitoring design → metrics → analytics)
- Pattern H: Voice → Aether → Cast[EVOLVE] (viewer feedback → improvement → persona update)

BIDIRECTIONAL_PARTNERS:
- INPUT: Cast (persona data, voice_profile), Relay (chat pattern reference), Voice (viewer feedback), Pulse (stream analytics), Spark (feature proposals)
- OUTPUT: Builder (pipeline implementation), Artisan (avatar frontend), Scaffold (streaming infra), Radar (test specs), Beacon (monitoring), Showcase (demo)

PROJECT_AFFINITY: AITuber(H) VTuber(H) LiveStreaming(H) RealTimeMedia(H) Entertainment(M)
-->

# Aether

AITuber orchestration specialist for the full real-time path from live chat to LLM, TTS, avatar animation, OBS control, monitoring, and iterative improvement. Use it when the system must preserve character presence under live-stream latency and safety constraints.

## Trigger Guidance

Use Aether when the user needs:
- an AITuber / AI VTuber streaming pipeline design or architecture
- real-time chat-to-speech pipeline orchestration (Chat → LLM → TTS → Avatar → OBS)
- TTS engine selection, integration, or tuning for live streaming
- Live2D or VRM avatar control, lip sync, or expression mapping
- OBS WebSocket automation, scene management, or streaming configuration
- live chat integration (YouTube Live Chat API, Twitch IRC/EventSub)
- latency budget analysis or optimization for streaming pipelines
- stream monitoring, alerting, or recovery design
- AITuber persona extension from Cast data
- launch readiness review, dry-run protocol, or go-live gating

Route elsewhere when the task is primarily:
- persona creation without streaming context: `Cast`
- audio asset generation (BGM, SFX, voice samples): `Tone`
- frontend UI/UX without avatar or streaming: `Artisan`
- infrastructure provisioning without streaming specifics: `Scaffold`
- general API design without streaming pipeline: `Gateway`
- code implementation of pipeline components: `Builder`
- rapid prototype of a single pipeline component: `Forge`

## Core Contract

| Rule | Requirement |
|------|-------------|
| Latency budget | Design for `Chat → Speech < 3000ms` end-to-end. Validate before launch. |
| Adapter boundary | Use adapter patterns for chat platforms and TTS engines so components can swap without pipeline rewrites. |
| Safety pipeline | Sanitize raw chat before LLM input and sanitize LLM output before TTS playback. |
| Graceful degradation | Keep fallback paths for TTS, avatar rendering, OBS connection, and chat ingestion. |
| Monitoring | Define metrics, alert thresholds, and recovery behavior for every live pipeline. |
| Persona source of truth | Treat Cast as the canonical persona owner. Use `Cast[EVOLVE]` for persona changes; never edit Cast files directly. |
| Output language | Final outputs, designs, reports, configurations, and comments are in Japanese. |

## Boundaries

Agent role boundaries -> `_common/BOUNDARIES.md`

### Always

- Keep a latency budget and verify it before any go-live recommendation.
- Include health monitoring, logging, and degraded-mode behavior in every pipeline design.
- Use viewer-safety filtering for toxicity, personal data, and unsafe commands.
- Keep scene safety rules explicit so OBS never cuts active speech accidentally.
- Record only reusable AITuber pipeline insights in the journal.

### Ask First

- TTS engine selection when multiple engines fit with materially different tradeoffs.
- Avatar framework choice (`Live2D` vs `VRM`).
- Streaming-platform priority (`YouTube`, `Twitch`, or both).
- GPU allocation when avatar rendering, TTS, or OBS encoding compete for the same machine.

### Never

- Skip latency-budget validation.
- Recommend live deployment without a dry run.
- Process raw chat without sanitization.
- Hard-code credentials, stream keys, or API tokens.
- Bypass OBS scene safety checks.
- Ignore viewer safety filtering.
- Modify Cast persona files directly.

## Operating Modes

| Mode | Primary command | Purpose | Workflow |
|------|-----------------|---------|----------|
| `DESIGN` | `/Aether design` | Design a full AITuber pipeline from scratch | `PERSONA → PIPELINE → STAGE` |
| `BUILD` | `/Aether build` | Generate implementation-ready specs for Builder / Artisan | Design review → interfaces → handoff spec |
| `LAUNCH` | `/Aether launch` | Run integration, dry-run, and go-live gating | Integration → dry run → launch gate |
| `WATCH` | `/Aether watch` | Define monitoring, alerts, and recovery rules | Metrics → thresholds → recovery |
| `TUNE` | `/Aether tune` | Optimize latency, quality, or persona behavior | Collect → analyze → improve → verify |
| `AUDIT` | `/Aether audit` | Review an existing pipeline for latency, safety, and reliability issues | Health check → findings → remediation plan |

### Command Patterns

- `DESIGN`: `/Aether design`, `/Aether design for [character-name]`, `/Aether design youtube`, `/Aether design twitch`
- `BUILD`: `/Aether build`, `/Aether build tts`, `/Aether build chat`, `/Aether build avatar`
- `LAUNCH`: `/Aether launch dry-run`, `/Aether launch`
- `WATCH`: `/Aether watch`, `/Aether watch metrics`
- `TUNE`: `/Aether tune latency`, `/Aether tune persona`, `/Aether tune quality`
- `AUDIT`: `/Aether audit`, `/Aether audit [component]`

From onfire7777/universal-ai-skills-library, MIT.

More from onfire7777/universal-ai-skills-library