# What Is the DomainGroup Enum in OpenHuman? Runtime Domain Control Explained

> Understand the DomainGroup enum in OpenHuman for runtime domain control. Learn how it manages active feature families, controller registration, tool visibility, and store initialization.

- Repository: [Tiny Humans/openhuman](https://github.com/tinyhumansai/openhuman)
- Tags: api-reference
- Published: 2026-08-31

---

**The `DomainGroup` enum is the central runtime switch that determines which feature families (domains) are active in an OpenHuman process, controlling controller registration, tool visibility, and store initialization.**

The `DomainGroup` enum serves as the backbone of OpenHuman's modular architecture in the `tinyhumansai/openhuman` repository, allowing the system to ship lean binaries while supporting extensive optional capabilities. Defined in the core runtime, this enum determines which controllers, agent tools, and persistence stores are compiled into and activated within a running instance according to the source code in [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs).

## DomainGroup Enum Definition and Structure

In [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs), the `DomainGroup` enum (around line 91) defines the complete set of logical feature families available in the OpenHuman ecosystem. Each variant represents a distinct domain that owns specific controllers, stores, and runtime behaviors.

### Core Variants and Architecture

The enum definition includes variants for major system capabilities:

```rust
pub enum DomainGroup {
    Agent,
    Memory,
    Threads,
    Config,
    Security,
    Automation,
    Integrations,
    Platform,
    Medulla,
    Channels,
    Web3,
    Mcp,
    Flows,
    Skills,
    Media,
    Voice,
    Hosted,
    Desktop,
    Runtimes,
    Inference,
}

```

The `DomainGroup::ALL` constant and the `domain_group_all_lists_every_variant` test ensure that every variant is accounted for across registries. Adding a new family requires updating the enum, the `DomainSet` presets, and the registration code to maintain compile-time safety.

## How DomainGroup Controls Runtime Behavior

The enum functions as a **gatekeeper** throughout the OpenHuman stack, determining which code paths execute during initialization and which remain dormant.

### DomainSet and CoreBuilder Integration

At startup, `CoreBuilder` constructs a `DomainSet` containing the active `DomainGroup` variants. The builder presets in [`src/core/runtime/builder.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/runtime/builder.rs) define common configurations:

- **`DomainSet::full()`**: Activates all available domains for a complete instance
- **`DomainSet::harness()`**: Minimal set for testing environments
- **Custom iteration**: Select specific domains via `DomainSet::from_iter()`

Only domains present in this set are registered; omitted domains become invisible to the RPC layer and are treated as "unknown-method" calls.

### Controller Registration Gating

During core initialization in [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs), the system checks domain membership before registering controllers:

```rust
if domains.allows(DomainGroup::Web3) {
    register_web3_controllers(&mut builder);
}

```

If `Web3` is not included in the active `DomainSet`, the corresponding controllers are never registered, effectively stripping that functionality from the process rather than merely disabling it.

### Tool Classification and Registry Filtering

The `tool_group` function in [`src/openhuman/tools/ops.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/ops.rs) maps agent tool names to their owning `DomainGroup`:

```rust
pub fn tool_group(name: &str) -> DomainGroup {
    // Maps tool prefixes to domain variants
    // e.g., "wallet_status" -> DomainGroup::Web3
}

```

When a domain is disabled, the tool registry automatically omits associated tools, preventing agents from accessing unavailable functionality.

## Practical Implementation Examples

### Checking Domain Availability

Determine whether specific functionality is active before executing domain-dependent logic:

```rust
use openhuman_core::core::all::{DomainGroup, DomainSet};

fn is_web3_enabled(domains: &DomainSet) -> bool {
    domains.allows(DomainGroup::Web3)
}

```

### Building a Minimal Core Configuration

Construct a lightweight OpenHuman instance with only essential domains:

```rust
use openhuman_core::core::{
    builder::CoreBuilder,
    runtime::{DomainSet, ServiceSet},
    all::DomainGroup,
};

let core = CoreBuilder::new()
    .domains(DomainSet::from_iter([
        DomainGroup::Agent,
        DomainGroup::Memory
    ]))
    .services(ServiceSet::none())
    .build()
    .await?;

```

This configuration registers only the `Agent` and `Memory` domains, excluding Web3, Voice, Media, and other optional capabilities to reduce resource consumption and attack surface.

### Mapping Tools to Domain Groups

Automatically classify tools based on naming conventions:

```rust
use openhuman_core::openhuman::tools::ops::tool_group;
use openhuman_core::core::all::DomainGroup;

let tool_name = "wallet_status";
let domain = tool_group(tool_name);
assert_eq!(domain, DomainGroup::Web3);

```

## DomainGroup Impact on System Architecture

Beyond simple feature toggles, the enum enforces architectural boundaries that affect persistence and security.

### Store Ownership and Persistence

In [`src/core/runtime/context.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/runtime/context.rs), each persistent store is linked to a specific `DomainGroup`. When a domain is disabled, its associated stores are never initialized on disk, preventing data corruption from partial configurations and ensuring clean separation between domain-specific data.

### Modular Security and Binary Size

The `DomainGroup` system enables compile-time and runtime pruning of unused capabilities. By excluding domains from the `DomainSet`, operators can reduce binary size by omitting unused controller code paths and minimize attack surface by disabling unnecessary RPC namespaces.

## Summary

- The `DomainGroup` enum in [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs) defines all available feature families in OpenHuman, including `Agent`, `Memory`, `Web3`, `Voice`, and `Flows`.
- **`DomainSet`** configurations determine which domains are active at runtime, with `CoreBuilder` handling the initialization logic in [`src/core/runtime/builder.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/runtime/builder.rs).
- Controllers are conditionally registered based on `domains.allows(DomainGroup::Variant)` checks in [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs), completely excluding disabled functionality from the RPC layer.
- The `tool_group` function in [`src/openhuman/tools/ops.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/ops.rs) automatically classifies agent tools by domain, hiding tools when their associated domain is inactive.
- Store initialization in [`src/core/runtime/context.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/runtime/context.rs) respects domain boundaries, ensuring disabled domains never create persistent storage.
- This architecture supports modular deployment, allowing operators to ship minimal binaries while maintaining the option to enable advanced capabilities through configuration changes.

## Frequently Asked Questions

### What happens if I call a tool from a disabled DomainGroup?

The tool registry automatically filters out tools belonging to inactive domains. If an agent attempts to invoke such a tool, the system returns an "unknown-method" error, identical to calling a non-existent function. This prevents accidental execution of disabled capabilities while maintaining consistent error handling across the RPC layer.

### How do I add a custom domain to OpenHuman?

Adding a new domain requires three steps: First, add a new variant to the `DomainGroup` enum in [`src/core/all.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/core/all.rs). Second, update the `domain_group_all_lists_every_variant` test to include your new variant. Finally, wrap your controller registration logic with `if domains.allows(DomainGroup::YourVariant)` checks to conditionally load the domain based on the active `DomainSet`.

### Can I change DomainGroup settings after the core starts?

No, `DomainGroup` membership is determined at initialization time through `CoreBuilder` and remains immutable for the process lifetime. The `DomainSet` is fixed after `CoreBuilder::build()` completes to ensure consistent runtime behavior. To change active domains, you must restart the process with a different `DomainSet` configuration.

### Where does OpenHuman define which tools belong to which DomainGroup?

The mapping logic resides in [`src/openhuman/tools/ops.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/ops.rs) within the `tool_group` function. This helper analyzes tool names and returns the appropriate `DomainGroup` variant. For example, tools prefixed with "wallet_" or "blockchain_" return `DomainGroup::Web3`, while audio processing tools map to `DomainGroup::Voice`, as implemented in the `tinyhumansai/openhuman` source code.