Solutions

Products

Pricing

Resources

Github

SOLUTIONS

Train models without centralizing participant data

Stoffel helps federated-learning teams keep data local, aggregate updates over MPC shares, and open only the model update or metric the workflow needs.

See how private aggregation works

See private aggregation

Schedule a call to remove central-aggregator risk

Schedule a call

Learn from shared signals without pooling participant data

Healthcare and medical AI

Train across hospitals, labs, or clinics without pooling patient records.

Let the shared model improve from each site’s data boundary.

Open the aggregate update while patient-level data stays local.

Financial services and risk models

Improve fraud, credit, or risk models across institutions.

Avoid exposing customer-level data or readable updates to one aggregator.

Keep model improvement tied to a clear aggregate output.

Institutional analytics and benchmarking

Compute shared metrics across organizations.

Avoid turning one vendor, partner, or operator into the reader for everyone’s data.

Open only the agreed metric, model update, or aggregate artifact.

Aggregation should not create a central reader

Federated learning can still create a trust bottleneck if every update arrives readable. Stoffel moves aggregation into MPC so individual contributions stay outside the shared view.

Data stays where it is

Each participant trains or computes inside its own boundary.

The workflow does not start by pooling datasets somewhere else.

Updates move as shares

MPC protects the aggregation step from one central reader.

Only the aggregate opens

Open the model update, metric, or output the workflow needs.

Keep individual contributions out of the shared view.

Participant data stays local

Private aggregation boundary

Participant data stays local

Private aggregation

Secure MPC

Agreed model update

No central readable update stream

From local training to one agreed model update

Participants keep training inside their own environments. Stoffel moves aggregation over shares so the workflow opens only the agreed update or metric.

Train locally

Participants train or compute inside their own environment. Data stays inside the local boundary.

Aggregate privately

Updates join a shared computation without one server reading every value.

Open the agreed update

Use the aggregate model update, metric, or output the workflow needs.

Partner proof

T-RIZE builds for institutional workflows where trust boundaries matter

T-RIZE builds institutional tokenization infrastructure for real-world assets. The same trust-boundary question applies to private aggregation: which participant, vendor, or server should be able to read everyone’s contribution?

Add private aggregation without rebuilding your training loop

Use Stoffel around the aggregation boundary. Keep local training in place while the shared computation protects the update path.

Minimal changes

# aggregate.stfl
def main() -> None:
  var client_0 = ClientStore.take_share(0, 0)
  var client_1 = ClientStore.take_share(1, 0)
  var model_update = Share.add(client_0, client_1)
  MpcOutput.send_to_client(0, [model_update])

Minimal changes

# aggregate.stfl
def main() -> None:
  var client_0 = ClientStore.take_share(0, 0)
  var client_1 = ClientStore.take_share(1, 0)
  var model_update = Share.add(client_0, client_1)
  MpcOutput.send_to_client(0, [model_update])

01 Keep local training in place

Keep local training or local computation inside each participant’s environment.

02 Wrap the aggregation boundary

Move the sensitive update step into MPC shares instead of sending readable updates to one server.

03 Open the output your workflow needs

Use the aggregate update, metric, or result in the product path you already have.

Schedule a call to remove central-aggregator risk

FAQ

Bring us the point where one server, vendor, or partner receives readable updates. We’ll help map what stays local, what runs over shares, and what opens.

What is federated learning?

Federated learning trains or improves a model across distributed participants without first pooling every participant’s dataset in one place. Each participant trains or computes locally, then contributes updates that are aggregated into a shared model or metric.

Where does secure MPC fit into federated learning?

Secure MPC can protect the aggregation step. Instead of one central server receiving every readable update, participants can contribute through shares and open only the aggregate update or metric the workflow needs.

Is this the same as secure aggregation?

Secure aggregation is a common privacy-preserving technique for federated learning. Stoffel’s framing is broader: use MPC to make the aggregation boundary private, so participant data and individual contributions are not exposed to one central reader.

When is federated learning useful?

Federated learning is useful when models improve from distributed data but pooling that data creates privacy, governance, security, or product-trust friction. Common use cases include healthcare, financial services, institutional analytics, industrial IoT, edge learning, and collaborative research.