OpenFang: Autonomous Agent Operating System

OpenFang includes 7 pre-built autonomous Hands:

The rust-expert Skill provides guidance on writing safe, performant, and idiomatic Rust code. It focuses on leveraging the type system to encode invariants, managing ownership and lifetimes, and handling concurrency using the tokio runtime.

Key Principles

• Type-Driven Design: Use the type system to make invalid states unrepresentable (e.g., use enums instead of boolean flags, and newtypes instead of raw primitives).
• Ownership & API Design: Prefer owned types at API boundaries and borrows within function bodies to simplify lifetime management.
• Error Handling: Handle errors explicitly using Result. Use thiserror for library-level errors and anyhow for application-level error propagation.
• Safe Abstractions: Reserve unsafe code only for cases where safe abstractions cannot express the operation, and always document safety invariants.
• Trait Design: Design traits with minimal required methods and provide default implementations where possible.

The interview-prep skill acts as a technical interview coach specializing in algorithms, system design, and behavioral assessments. It provides structured preparation strategies and pattern recognition frameworks to help candidates prepare for engineering roles at top technology companies.

Core Capabilities

• Algorithm Preparation: Focuses on mastering core patterns (e.g., Two Pointers, Sliding Window, BFS/DFS, Dynamic Programming, Binary Search, Backtracking) rather than memorizing individual problems.
• System Design Coaching: Provides a repeatable framework: clarify requirements $\rightarrow$ estimate scale $\rightarrow$ design architecture $\rightarrow$ deep-dive into components.
• Behavioral Coaching: Uses the STAR method (Situation, Task, Action, Result) to help prepare quantifiable stories for leadership, conflict resolution, and technical decision-making.
• Complexity Analysis: Guides users through expressing Big-O time and space complexity and explaining tradeoffs.

Recommended Preparation Workflow

1. Clarify: Always restate the problem and clarify edge cases/constraints before coding.
2. Discuss: Explain your approach and discuss complexity before implementation.
3. Implement: Write clean code and test it with examples.
4. Optimize: Start with a correct brute-force solution and improve complexity incrementally to avoid premature optimization.

The data-pipeline Skill provides guidance for designing and operating production-grade ETL/ELT pipelines, orchestration frameworks, and data quality systems. It covers batch and streaming architectures using industry-standard tools like Apache Airflow, Apache Spark, and dbt.

Core Principles

• Prefer ELT over ETL: Load raw data into your warehouse first, then transform it in place to ensure reproducibility and auditability.
• Idempotency: Ensure every pipeline step is idempotent; re-running a task with the same inputs must produce the same outputs without side effects or duplicates.
• Partitioning: Partition data by time or logical keys at every stage to enable incremental processing, efficient pruning, and manageable backfill operations.
• Data Quality Gates: Instrument pipelines with quality checks between stages to prevent cascading corruption.
• Separation of Concerns: Separate orchestration (scheduling/ordering) from computation (heavy processing).