# Spiking Networks

Every registered spiking networks instance operation, with source-derived inputs, outputs, access policy, and errors.

Source: https://docs.minds.sh/docs/api/instance/spiking-networks



This reference covers **16 HTTP operations** registered by the Akasha daemon. Call these paths on your instance base URL. See [authentication](/docs/api/instance/authentication), [errors](/docs/api/instance/errors), and [coverage](/docs/api/instance/coverage) before integrating.

| Method | Path                              | Operation                                                           |
| ------ | --------------------------------- | ------------------------------------------------------------------- |
| `POST` | `/v1/snn/network/build`           | [Snn build](#post-v1-snn-network-build)                             |
| `POST` | `/v1/snn/network/compile`         | [Snn compile](#post-v1-snn-network-compile)                         |
| `POST` | `/v1/snn/network/step`            | [Snn step](#post-v1-snn-network-step)                               |
| `POST` | `/v1/snn/train/bptt`              | [Snn train bptt](#post-v1-snn-train-bptt)                           |
| `POST` | `/v1/snn/network/state`           | [Snn state](#post-v1-snn-network-state)                             |
| `POST` | `/v1/snn/federation/register`     | [Snn federation register](#post-v1-snn-federation-register)         |
| `POST` | `/v1/snn/federation/contribute`   | [Snn federation contribute](#post-v1-snn-federation-contribute)     |
| `POST` | `/v1/snn/federation/parameters`   | [Snn federation parameters](#post-v1-snn-federation-parameters)     |
| `POST` | `/v1/snn/federation/spike`        | [Snn federation spike](#post-v1-snn-federation-spike)               |
| `POST` | `/v1/snn/federation/capabilities` | [Snn federation capabilities](#post-v1-snn-federation-capabilities) |
| `POST` | `/v1/snn/federation/agent/update` | [Snn federation agent update](#post-v1-snn-federation-agent-update) |
| `POST` | `/v1/snn/federation/agent/remove` | [Snn federation agent remove](#post-v1-snn-federation-agent-remove) |
| `POST` | `/v1/snn/federation/spikes`       | [Snn federation spikes recent](#post-v1-snn-federation-spikes)      |
| `GET`  | `/v1/snn/health`                  | [Snn health](#get-v1-snn-health)                                    |
| `GET`  | `/v1/snn/stats`                   | [Snn stats](#get-v1-snn-stats)                                      |
| `POST` | `/v1/snn/neurons`                 | [Snn neurons](#post-v1-snn-neurons)                                 |

<a id="post-v1-snn-network-build" />

## POST `/v1/snn/network/build` [#post-v1snnnetworkbuild]

Snn build

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped( CoreAction::Write, "snn:write", request\_authority::MEMORY\_SNN, ); require\_scoped( CoreAction::Admin, "snn:admin", request\_authority::MEMORY\_SNN, ); require\_matching\_db(\&scoped\_db).

### Request [#request]

**Json** — `SnnBuildReq`

| Field                             | Rust type                   | Required on input                          | Notes            |
| --------------------------------- | --------------------------- | ------------------------------------------ | ---------------- |
| `network_id`                      | `Option<String>`            | No; optional or defaulted                  |                  |
| `namespace`                       | `Option<String>`            | No; optional or defaulted                  |                  |
| `version`                         | `Option<String>`            | No; optional or defaulted                  |                  |
| `spec`                            | `Option<serde_json::Value>` | No; optional or defaulted                  |                  |
| Flattened `body_authority` fields | `RejectedBodyAuthority`     | See flattened type; not a named JSON field | Serde: `flatten` |

```rust
struct SnnBuildReq {
    network_id: Option<String>,
    namespace: Option<String>,
    version: Option<String>,
    spec: Option<serde_json::Value>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}
```

### Response [#response]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
response
```

### Errors and validation [#errors-and-validation]

Directly referenced error variants: `Forbidden`, `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_build(
        State(state): State<AppState>,
        Extension(scoped_db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnBuildReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        req.body_authority.reject()?;
        authority.require_scoped(
            CoreAction::Write,
            "snn:write",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_scoped(
            CoreAction::Admin,
            "snn:admin",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_matching_db(&scoped_db)?;
        let namespace = req
            .namespace
            .ok_or_else(|| DaemonError::InvalidRequest("namespace is required".into()))?;
        let network_spec = req
            .spec
            .ok_or_else(|| DaemonError::InvalidRequest("network spec is required".into()))?;
        let namespace_id = decode_namespace_hex(&namespace)?;
        if authority.namespace() != namespace_id {
            return Err(DaemonError::Forbidden(
                "request namespace does not match verified authority".into(),
            ));
        }

        let storage = Arc::new(SnnStorage::new(scoped_db.clone()));
        storage.ensure_keyspaces().await?;

        let network_id = req
            .network_id
            .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
        let version = req
            .version
            .unwrap_or_else(|| format!("v{}", chrono::Utc::now().timestamp()));

        let metadata = serde_json::json!({
            "created_by": "akasha-daemon",
            "timestamp": chrono::Utc::now().to_rfc3339(),
        });

        storage
            .store_network(
                namespace_id,
                &network_id,
                &version,
                &network_spec,
                &metadata,
            )
            .await?;

        let response = SnnBuildResponse {
            network_id: network_id.clone(),
            namespace: namespace.clone(),
            version: version.clone(),
        };

        // Register storage with the SNN registry
        state
            .snn_registry()
            .await?
            .register_namespace(namespace_id, storage.clone())
            .await;
        state
            .ensure_snn_runtime(namespace_id, scoped_db, None)
            .await?;

        Ok(Json(response))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:8975`. Registration: `akasha-daemon/src/main.rs:4463`.

<a id="post-v1-snn-network-compile" />

## POST `/v1/snn/network/compile` [#post-v1snnnetworkcompile]

Snn compile

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped( CoreAction::Write, "snn:write", request\_authority::MEMORY\_SNN, ); require\_scoped( CoreAction::Query, "snn:execute", request\_authority::MEMORY\_SNN, ); require\_matching\_db(\&scoped\_db).

### Request [#request-1]

**Json** — `SnnCompileReq`

| Field                             | Rust type               | Required on input                          | Notes            |
| --------------------------------- | ----------------------- | ------------------------------------------ | ---------------- |
| `network_id`                      | `String`                | Yes                                        |                  |
| `namespace`                       | `String`                | Yes                                        |                  |
| `version`                         | `Option<String>`        | No; optional or defaulted                  |                  |
| Flattened `body_authority` fields | `RejectedBodyAuthority` | See flattened type; not a named JSON field | Serde: `flatten` |

```rust
struct SnnCompileReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}
```

**JSON field accesses in handler:** `input`, `output`, `spec`. Nested lookups are included; this list alone does not establish requiredness.

### Response [#response-1]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
SnnCompileResponse {
        compiled_id: req.network_id.clone(),
        version: version.clone(),
    }
```

### Errors and validation [#errors-and-validation-1]

Directly referenced error variants: `Forbidden`, `Internal`, `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_compile(
        State(state): State<AppState>,
        Extension(scoped_db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnCompileReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        req.body_authority.reject()?;
        authority.require_scoped(
            CoreAction::Write,
            "snn:write",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_scoped(
            CoreAction::Query,
            "snn:execute",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_matching_db(&scoped_db)?;
        let namespace_id = decode_namespace_hex(&req.namespace)?;
        if authority.namespace() != namespace_id {
            return Err(DaemonError::Forbidden(
                "request namespace does not match verified authority".into(),
            ));
        }
        let storage = Arc::new(SnnStorage::new(scoped_db.clone()));
        storage.ensure_keyspaces().await?;

        let network = storage
            .find_network(namespace_id, &req.network_id, req.version.as_deref())
            .await?
            .ok_or_else(|| DaemonError::InvalidRequest("network not found".into()))?;
        let spec_value = network
            .get("spec")
            .cloned()
            .ok_or_else(|| DaemonError::Internal("network spec missing".into()))?;

        let version = req.version.unwrap_or_else(|| "latest".to_string());

        let parsed_spec: snn::storage::NetworkSpec = serde_json::from_value(spec_value)
            .map_err(|e| DaemonError::InvalidRequest(format!("invalid network spec: {e}")))?;

        let mut builder = NetworkBuilder::new();
        if let Some(label) = parsed_spec.label.clone() {
            builder = builder.with_label(label);
        }
        if let Some(seed) = parsed_spec.seed {
            builder = builder.with_seed(seed);
        }

        let mut dims_by_ensemble = HashMap::new();
        for (name, value) in parsed_spec.ensembles.iter() {
            let ensemble_spec: SnnEnsembleSpec =
                serde_json::from_value(value.clone()).map_err(|e| {
                    DaemonError::InvalidRequest(format!("invalid ensemble spec '{name}': {e}"))
                })?;
            dims_by_ensemble.insert(name.clone(), ensemble_spec.dimensions);

            let mut cfg = akasha_snn::builder::EnsembleConfig::default();
            cfg.n_neurons = ensemble_spec.n_neurons;
            cfg.dimensions = ensemble_spec.dimensions;
            cfg.radius = ensemble_spec.radius;
            cfg.seed = ensemble_spec.seed;
            cfg.label = ensemble_spec.label.or_else(|| Some(name.clone()));

            builder.add_ensemble(name, cfg).map_err(|e| {
                DaemonError::InvalidRequest(format!("failed to add ensemble '{name}': {e}"))
            })?;
        }

        let network = builder
            .build()
            .map_err(|e| DaemonError::InvalidRequest(format!("network build error: {e}")))?;

        let input_dims = dims_by_ensemble
            .get("input")
            .copied()
            .or_else(|| dims_by_ensemble.values().next().copied())
            .unwrap_or(1);
        let output_dims = dims_by_ensemble
            .get("output")
            .copied()
            .unwrap_or(input_dims);

        let metadata = akasha_snn::inference::NetworkMetadata {
            name: parsed_spec.label.unwrap_or_else(|| req.network_id.clone()),
            version: version.clone(),
            input_dims,
            output_dims,
            dt: 0.001,
            compiled_at: chrono::Utc::now().to_rfc3339(),
        };

        let compiled = akasha_snn::inference::CompiledNetwork::from_network(&network, metadata)
            .map_err(|e| DaemonError::Internal(e.to_string()))?;
        let bytes = compiled
            .to_bytes()
            .map_err(|e| DaemonError::Internal(e.to_string()))?;

        let registry = state.snn_registry().await?;
        registry
            .register_namespace(namespace_id, storage.clone())
            .await;
        registry
            .insert_compiled(namespace_id, &req.network_id, &version, bytes)
            .await?;

        if let Some(service) = state.inference_service.as_ref() {
            upsert_snn_model(service, namespace_id, &req.network_id, &version);
        }

        Ok(Json(SnnCompileResponse {
            compiled_id: req.network_id.clone(),
            version: version.clone(),
        }))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9050`. Registration: `akasha-daemon/src/main.rs:4464`.

<a id="post-v1-snn-network-step" />

## POST `/v1/snn/network/step` [#post-v1snnnetworkstep]

Snn step

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped( CoreAction::Query, "snn:execute", request\_authority::MEMORY\_SNN, ); require\_matching\_db(\&scoped).

### Request [#request-2]

**Json** — `SnnStepReq`

| Field                             | Rust type               | Required on input                          | Notes            |
| --------------------------------- | ----------------------- | ------------------------------------------ | ---------------- |
| `network_id`                      | `String`                | Yes                                        |                  |
| `namespace`                       | `String`                | Yes                                        |                  |
| `version`                         | `Option<String>`        | No; optional or defaulted                  |                  |
| `input`                           | `Vec<f32>`              | Yes                                        |                  |
| Flattened `body_authority` fields | `RejectedBodyAuthority` | See flattened type; not a named JSON field | Serde: `flatten` |

```rust
struct SnnStepReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    input: Vec<f32>,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}
```

### Response [#response-2]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
SnnStepResponse { output: result_vec }
```

### Errors and validation [#errors-and-validation-2]

Directly referenced error variants: `Forbidden`, `Internal`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_step(
        State(state): State<AppState>,
        Extension(scoped): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnStepReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        req.body_authority.reject()?;
        authority.require_scoped(
            CoreAction::Query,
            "snn:execute",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_matching_db(&scoped)?;
        let namespace_id = decode_namespace_hex(&req.namespace)?;
        if authority.namespace() != namespace_id {
            return Err(DaemonError::Forbidden(
                "request namespace does not match verified authority".into(),
            ));
        }
        let version = req.version.clone().unwrap_or_else(|| "latest".to_string());
        let registry = state.snn_registry().await?;
        state
            .ensure_snn_runtime(namespace_id, scoped, Some(req.input.len()))
            .await?;
        let engine = registry
            .get_or_load(namespace_id, &req.network_id, &version)
            .await?;

        let input = Array1::from_vec(req.input.clone());
        let mut guard = engine.lock().await;
        let output = guard
            .step(&input)
            .map_err(|e| DaemonError::Internal(e.to_string()))?;

        let result_vec = output.to_vec();
        if let Some(runtime) = registry.runtime(&namespace_id).await {
            runtime
                .emit_spike(&req.network_id, &version, &result_vec)
                .await;
        }

        Ok(Json(SnnStepResponse { output: result_vec }))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9166`. Registration: `akasha-daemon/src/main.rs:4465`.

<a id="post-v1-snn-train-bptt" />

## POST `/v1/snn/train/bptt` [#post-v1snntrainbptt]

Snn train bptt

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped( CoreAction::Write, "snn:train", request\_authority::MEMORY\_SNN, ); require\_matching\_db(\&scoped\_db).

### Request [#request-3]

**Implementation limit:** Placeholder training: constructs a trainer but does not run BPTT. Records placeholder completed metrics and saves a versioned spec; do not interpret success as learned weights.

**Json** — `SnnTrainBpttReq`

| Field                             | Rust type               | Required on input                          | Notes            |
| --------------------------------- | ----------------------- | ------------------------------------------ | ---------------- |
| `network_id`                      | `String`                | Yes                                        |                  |
| `namespace`                       | `String`                | Yes                                        |                  |
| `version`                         | `Option<String>`        | No; optional or defaulted                  |                  |
| `steps`                           | `usize`                 | Yes                                        |                  |
| Flattened `body_authority` fields | `RejectedBodyAuthority` | See flattened type; not a named JSON field | Serde: `flatten` |

```rust
struct SnnTrainBpttReq {
    network_id: String,
    namespace: String,
    version: Option<String>,
    steps: usize,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}
```

**JSON field accesses in handler:** `spec`. Nested lookups are included; this list alone does not establish requiredness.

### Response [#response-3]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
SnnTrainBpttResponse {
        network_id: req.network_id,
        version,
    }
```

### Errors and validation [#errors-and-validation-3]

Directly referenced error variants: `Forbidden`, `Internal`, `InvalidRequest`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_train_bptt(
        State(state): State<AppState>,
        Extension(scoped_db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnTrainBpttReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        req.body_authority.reject()?;
        authority.require_scoped(
            CoreAction::Write,
            "snn:train",
            request_authority::MEMORY_SNN,
        )?;
        authority.require_matching_db(&scoped_db)?;
        let namespace_id = decode_namespace_hex(&req.namespace)?;
        if authority.namespace() != namespace_id {
            return Err(DaemonError::Forbidden(
                "request namespace does not match verified authority".into(),
            ));
        }
        let storage = SnnStorage::new(scoped_db.clone());
        storage.ensure_keyspaces().await?;

        let network = storage
            .find_network(namespace_id, &req.network_id, req.version.as_deref())
            .await?
            .ok_or_else(|| DaemonError::InvalidRequest("network not found".into()))?;
        let spec = network
            .get("spec")
            .cloned()
            .ok_or_else(|| DaemonError::Internal("network spec missing".into()))?;
        // Exercise NetworkSpec fields parsing to avoid dead-code lints
        if let Ok(parsed) = serde_json::from_value::<snn::storage::NetworkSpec>(spec.clone()) {
            let _ = (
                parsed.label,
                parsed.seed,
                parsed.ensembles.len(),
                parsed.connections.len(),
            );
        }

        // Build network from spec (note: builder doesn't have from_json method)
        let builder = NetworkBuilder::new();
        let _network = builder
            .build()
            .map_err(|e| DaemonError::InvalidRequest(format!("network build error: {e}")))?;

        // BpttTrainer::new only takes config, not network
        let _trainer = BpttTrainer::new(BpttConfig::default());

        // Note: The trainer API would need to be used differently in production
        // For now, create placeholder training metrics
        let version = format!("v{}-trained", req.steps);
        let metrics = json!({
            "steps": req.steps,
            "status": "completed",
        });

        let training_metadata = json!({
            "trained_at": chrono::Utc::now().to_rfc3339(),
        });

        storage
            .record_training_run(
                namespace_id,
                &req.network_id,
                &version,
                &metrics,
                &training_metadata,
            )
            .await?;

        // Save trained network spec
        let trained_metadata = json!({
            "trained": true,
            "training_steps": req.steps,
        });

        storage
            .store_network(
                namespace_id,
                &req.network_id,
                &version,
                &spec,
                &trained_metadata,
            )
            .await?;
        if let Some(metrics) = state.snn_metrics.as_ref() {
            metrics
                .training_duration
                .observe((req.steps as f64) * 0.001);
        }

        if let Some(cfg) = modal_training_config_from_env()
            && let Err(err) = trigger_modal_training_job(cfg, &req, namespace_id).await
        {
            warn!(
                target: "akasha::snn::training",
                error = %err,
                "failed to submit Modal training job"
            );
        }

        Ok(Json(SnnTrainBpttResponse {
            network_id: req.network_id,
            version,
        }))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9210`. Registration: `akasha-daemon/src/main.rs:4466`.

<a id="post-v1-snn-network-state" />

## POST `/v1/snn/network/state` [#post-v1snnnetworkstate]

Snn state

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped(CoreAction::Read, "snn:read", request\_authority::MEMORY\_SNN); require\_matching\_db(\&scoped\_db).

### Request [#request-4]

**Json** — `SnnStateReq`

| Field                             | Rust type               | Required on input                          | Notes            |
| --------------------------------- | ----------------------- | ------------------------------------------ | ---------------- |
| `namespace`                       | `String`                | Yes                                        |                  |
| Flattened `body_authority` fields | `RejectedBodyAuthority` | See flattened type; not a named JSON field | Serde: `flatten` |

```rust
struct SnnStateReq {
    namespace: String,
    #[serde(flatten)]
    body_authority: RejectedBodyAuthority,
}
```

### Response [#response-4]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
SnnStateResponse {
        namespace: req.namespace,
        networks,
    }
```

### Errors and validation [#errors-and-validation-4]

Directly referenced error variants: `Forbidden`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_state(
        State(state): State<AppState>,
        Extension(scoped_db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnStateReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        req.body_authority.reject()?;
        authority.require_scoped(CoreAction::Read, "snn:read", request_authority::MEMORY_SNN)?;
        authority.require_matching_db(&scoped_db)?;
        let namespace_id = decode_namespace_hex(&req.namespace)?;
        if authority.namespace() != namespace_id {
            return Err(DaemonError::Forbidden(
                "request namespace does not match verified authority".into(),
            ));
        }
        let storage = SnnStorage::new(scoped_db);
        storage.ensure_keyspaces().await?;

        let networks = storage.query_networks(namespace_id).await?;
        // Touch SNN metrics fields to exercise all metrics
        if let Some(metrics) = state.snn_metrics.as_ref() {
            let _ = &metrics.load_failures;
            let _ = &metrics.training_duration;
        }
        // Touch SNN error Result alias
        let _snn_ok: snn::error::Result<()> = Ok(());
        let _ = _snn_ok;
        // Exercise SNN error enum variants
        let _ = (
            snn::error::SnnManagerError::Storage("warmup".into()),
            snn::error::SnnManagerError::NotFound("warmup".into()),
            snn::error::SnnManagerError::Capability("warmup".into()),
            snn::error::SnnManagerError::InvalidState("warmup".into()),
            snn::error::SnnManagerError::Internal("warmup".into()),
        );
        Ok(Json(SnnStateResponse {
            namespace: req.namespace,
            networks,
        }))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9318`. Registration: `akasha-daemon/src/main.rs:4467`.

<a id="post-v1-snn-federation-register" />

## POST `/v1/snn/federation/register` [#post-v1snnfederationregister]

Snn federation register

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-5]

**Json** — `SnnFederationRegisterReq`

| Field          | Rust type           | Required on input         | Notes            |
| -------------- | ------------------- | ------------------------- | ---------------- |
| `token`        | `Option<String>`    | No; optional or defaulted |                  |
| `agent_id`     | `String`            | Yes                       |                  |
| `host`         | `String`            | Yes                       |                  |
| `capabilities` | `Vec<String>`       | Yes                       |                  |
| `ensembles`    | `Vec<EnsembleInfo>` | No; optional or defaulted | Serde: `default` |
| `visibility`   | `Option<String>`    | No; optional or defaulted |                  |
| `trust_score`  | `Option<f32>`       | No; optional or defaulted | Serde: `default` |

```rust
struct SnnFederationRegisterReq {
    token: Option<String>,
    agent_id: String,
    host: String,
    capabilities: Vec<String>,
    #[serde(default)]
    ensembles: Vec<EnsembleInfo>,
    visibility: Option<String>,
    #[serde(default)]
    trust_score: Option<f32>,
}
```

### Response [#response-5]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-5]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_register(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationRegisterReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        let payload = AgentCapability {
            agent_id: req.agent_id,
            host: req.host,
            capabilities: req.capabilities,
            ensembles: req.ensembles,
            visibility: req.visibility.unwrap_or_else(|| "private".into()),
            trust_score: req.trust_score.unwrap_or(0.5),
            registered_at: Utc::now(),
        };
        coordinator
            .register_agent(req.token.as_deref(), payload)
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9359`. Registration: `akasha-daemon/src/main.rs:4468`.

<a id="post-v1-snn-federation-contribute" />

## POST `/v1/snn/federation/contribute` [#post-v1snnfederationcontribute]

Snn federation contribute

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-6]

**Json** — `SnnFederationContributeReq`

| Field      | Rust type        | Required on input         | Notes |
| ---------- | ---------------- | ------------------------- | ----- |
| `token`    | `Option<String>` | No; optional or defaulted |       |
| `agent_id` | `String`         | Yes                       |       |
| `deltas`   | `WeightDeltas`   | Yes                       |       |

```rust
struct SnnFederationContributeReq {
    token: Option<String>,
    agent_id: String,
    deltas: WeightDeltas,
}
```

### Response [#response-6]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(snapshot).unwrap_or_default()
```

### Errors and validation [#errors-and-validation-6]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_contribute(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationContributeReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        let snapshot = coordinator
            .submit_updates(req.token.as_deref(), &req.agent_id, req.deltas)
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::to_value(snapshot).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9380`. Registration: `akasha-daemon/src/main.rs:4469`.

<a id="post-v1-snn-federation-parameters" />

## POST `/v1/snn/federation/parameters` [#post-v1snnfederationparameters]

Snn federation parameters

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-7]

**Json** — `SnnFederationTokenReq`

| Field   | Rust type        | Required on input         | Notes |
| ------- | ---------------- | ------------------------- | ----- |
| `token` | `Option<String>` | No; optional or defaulted |       |

```rust
struct SnnFederationTokenReq {
    token: Option<String>,
}
```

### Response [#response-7]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(snapshot).unwrap_or_default()
```

### Errors and validation [#errors-and-validation-7]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_parameters(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationTokenReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        let snapshot = coordinator
            .parameters(req.token.as_deref())
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::to_value(snapshot).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9392`. Registration: `akasha-daemon/src/main.rs:4473`.

<a id="post-v1-snn-federation-spike" />

## POST `/v1/snn/federation/spike` [#post-v1snnfederationspike]

Snn federation spike

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-8]

**Json** — `SnnFederationSpikeReq`

| Field   | Rust type           | Required on input         | Notes |
| ------- | ------------------- | ------------------------- | ----- |
| `token` | `Option<String>`    | No; optional or defaulted |       |
| `event` | `SpikeEventPayload` | Yes                       |       |

```rust
struct SnnFederationSpikeReq {
    token: Option<String>,
    event: SpikeEventPayload,
}
```

### Response [#response-8]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-8]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_spike(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationSpikeReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        coordinator
            .propagate_spike(req.token.as_deref(), req.event)
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9404`. Registration: `akasha-daemon/src/main.rs:4477`.

<a id="post-v1-snn-federation-capabilities" />

## POST `/v1/snn/federation/capabilities` [#post-v1snnfederationcapabilities]

Snn federation capabilities

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-9]

**Json** — `SnnFederationCapabilitiesReq`

| Field      | Rust type             | Required on input         | Notes            |
| ---------- | --------------------- | ------------------------- | ---------------- |
| `token`    | `Option<String>`      | No; optional or defaulted |                  |
| `required` | `Option<Vec<String>>` | No; optional or defaulted | Serde: `default` |

```rust
struct SnnFederationCapabilitiesReq {
    token: Option<String>,
    #[serde(default)]
    required: Option<Vec<String>>,
}
```

### Response [#response-9]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(list).unwrap_or_default()
```

### Errors and validation [#errors-and-validation-9]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_capabilities(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationCapabilitiesReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        let required = req.required.unwrap_or_default();
        let list = coordinator
            .capabilities(req.token.as_deref(), &required)
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::to_value(list).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9416`. Registration: `akasha-daemon/src/main.rs:4478`.

<a id="post-v1-snn-federation-agent-update" />

## POST `/v1/snn/federation/agent/update` [#post-v1snnfederationagentupdate]

Snn federation agent update

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-10]

**Json** — `SnnFederationAgentUpdateReq`

| Field         | Rust type        | Required on input         | Notes |
| ------------- | ---------------- | ------------------------- | ----- |
| `token`       | `Option<String>` | No; optional or defaulted |       |
| `agent_id`    | `String`         | Yes                       |       |
| `visibility`  | `Option<String>` | No; optional or defaulted |       |
| `trust_score` | `Option<f32>`    | No; optional or defaulted |       |

```rust
struct SnnFederationAgentUpdateReq {
    token: Option<String>,
    agent_id: String,
    visibility: Option<String>,
    trust_score: Option<f32>,
}
```

### Response [#response-10]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(updated).unwrap_or_default()
```

### Errors and validation [#errors-and-validation-10]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_agent_update(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationAgentUpdateReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        let updated = coordinator
            .update_agent(
                req.token.as_deref(),
                &req.agent_id,
                req.visibility,
                req.trust_score,
            )
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::to_value(updated).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9429`. Registration: `akasha-daemon/src/main.rs:4482`.

<a id="post-v1-snn-federation-agent-remove" />

## POST `/v1/snn/federation/agent/remove` [#post-v1snnfederationagentremove]

Snn federation agent remove

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-11]

**Json** — `SnnFederationAgentRemoveReq`

| Field      | Rust type        | Required on input         | Notes |
| ---------- | ---------------- | ------------------------- | ----- |
| `token`    | `Option<String>` | No; optional or defaulted |       |
| `agent_id` | `String`         | Yes                       |       |

```rust
struct SnnFederationAgentRemoveReq {
    token: Option<String>,
    agent_id: String,
}
```

### Response [#response-11]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"ok": true})
```

### Errors and validation [#errors-and-validation-11]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_agent_remove(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationAgentRemoveReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        coordinator
            .deregister_agent(req.token.as_deref(), &req.agent_id)
            .await
            .map_err(DaemonError::from)?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9446`. Registration: `akasha-daemon/src/main.rs:4486`.

<a id="post-v1-snn-federation-spikes" />

## POST `/v1/snn/federation/spikes` [#post-v1snnfederationspikes]

Snn federation spikes recent

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-12]

**Json** — `SnnFederationTokenReq`

| Field   | Rust type        | Required on input         | Notes |
| ------- | ---------------- | ------------------------- | ----- |
| `token` | `Option<String>` | No; optional or defaulted |       |

```rust
struct SnnFederationTokenReq {
    token: Option<String>,
}
```

### Response [#response-12]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::to_value(list).unwrap_or_default()
```

### Errors and validation [#errors-and-validation-12]

Directly referenced error variants: `from`. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_federation_spikes_recent(
        State(state): State<AppState>,
        Json(req): Json<SnnFederationTokenReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        let coordinator = state.federation()?;
        coordinator
            .security()
            .validate(req.token.as_deref())
            .map_err(DaemonError::from)?;
        let list = coordinator.recent_spikes().await;
        Ok(Json(serde_json::to_value(list).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9458`. Registration: `akasha-daemon/src/main.rs:4490`.

<a id="get-v1-snn-health" />

## GET `/v1/snn/health` [#get-v1snnhealth]

Snn health

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-13]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-13]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

Serialization is delegated or the handler returns a raw response. Consult the exact handler below; the OpenAPI response intentionally remains unconstrained.

### Errors and validation [#errors-and-validation-13]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_health(State(state): State<AppState>) -> Result<impl IntoResponse, DaemonError> {
        service_health_payload(&state, "snn").await
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10301`. Registration: `akasha-daemon/src/main.rs:4494`.

<a id="get-v1-snn-stats" />

## GET `/v1/snn/stats` [#get-v1snnstats]

Snn stats

| Availability         | Source contract     |
| -------------------- | ------------------- |
| Registration         | `config.enable_snn` |
| Runtime service      | `snn`               |
| Handler dependencies | `SNN`               |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped(CoreAction::Read, "snn:read", request\_authority::MEMORY\_SNN); require\_matching\_db(\&db).

### Request [#request-14]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-14]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "cacheHits": metrics.cache_hits.get(),
        "cacheMisses": metrics.cache_misses.get(),
        "cacheEvictions": metrics.cache_evictions.get(),
        "loadFailures": metrics.load_failures.get()
    })
```

### Errors and validation [#errors-and-validation-14]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_stats(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        authority.require_scoped(CoreAction::Read, "snn:read", request_authority::MEMORY_SNN)?;
        authority.require_matching_db(&db)?;
        let metrics = require_service!(state.snn_metrics, "SNN");
        Ok(Json(serde_json::json!({
            "cacheHits": metrics.cache_hits.get(),
            "cacheMisses": metrics.cache_misses.get(),
            "cacheEvictions": metrics.cache_evictions.get(),
            "loadFailures": metrics.load_failures.get()
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11151`. Registration: `akasha-daemon/src/main.rs:4495`.

<a id="post-v1-snn-neurons" />

## POST `/v1/snn/neurons` [#post-v1snnneurons]

Snn neurons

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_snn`                        |
| Runtime service      | `snn`                                      |
| Handler dependencies | See handler source and return expressions. |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped. Handler additionally checks require\_scoped(CoreAction::Read, "snn:read", request\_authority::MEMORY\_SNN); require\_matching\_db(\&db).

### Request [#request-15]

**Json** — `SnnNeuronsReq`

| Field        | Rust type | Required on input | Notes |
| ------------ | --------- | ----------------- | ----- |
| `network_id` | `String`  | Yes               |       |

```rust
struct SnnNeuronsReq {
    network_id: String,
}
```

### Response [#response-15]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "networkId": req.network_id,
        "neurons": []
    })
```

### Errors and validation [#errors-and-validation-15]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn snn_neurons(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Extension(authority): Extension<RequestAuthority>,
        Json(req): Json<SnnNeuronsReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        authority.require_scoped(CoreAction::Read, "snn:read", request_authority::MEMORY_SNN)?;
        authority.require_matching_db(&db)?;
        // Without a scoped-db lookup, return basic info about the requested network
        let _registry = state.snn_registry().await?;
        Ok(Json(serde_json::json!({
            "networkId": req.network_id,
            "neurons": []
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11173`. Registration: `akasha-daemon/src/main.rs:4496`.