Skip to content

Code of Ethics

Why we have this code

Quiet Signals Lab builds software that reads sensitive documents: legal records, research libraries, screenshots and files full of personal data. We work with machine learning, and machine learning can be wrong, biased or misused. This code sets out the principles we build by and the specific things we commit to doing.

We are a small software lab based in the Netherlands. Our products use small language models that we train for one narrow job each, and they run on the user's own device. That design is itself an ethical choice. Data that never leaves a device cannot leak from a server, be sold or be quietly reused for training.

Scope. This code applies to everything we build and release, paid or open source. It covers how we collect and handle data, how we train and evaluate models, what we publish and what we refuse to build. It binds anyone who works on our software, including contractors and collaborators.

Who is accountable. The founder, Alexander Hepburn, is responsible for compliance with this code and for any licence terms we accept from data providers.

Our principles

Each principle is a plain statement, followed by what we actually do to keep it.

1. Privacy is designed in, not added on

We collect the least data a task needs, and we process it on the user's device wherever we can.

  • Our paid apps have no network entitlement. The operating system blocks them from making any outbound connection.
  • We collect no telemetry and no analytics from inside our apps, and we require no account.
  • When we use personal data to train or test a model, we have a lawful basis under the UK GDPR and EU GDPR. We record what we used, why, and when we will delete it.
  • Training data is stored encrypted, on machines we control, and is never shared with third parties for processing.

2. Models assist people; they do not decide for them

Our software makes suggestions. A person reviews them and makes the decision.

  • Every detection a model makes is shown to the user for review before it takes effect.
  • Where a model is less certain, as with names, we present its output as a suggestion, not an automatic action.
  • We do not build tools that give automated legal advice or predict the outcome of a case for a client.

3. We measure our errors and publish them

A model that is sometimes wrong is acceptable if users know how often and in which ways.

  • We evaluate each model on held-out test sets before release and record its precision and recall per category and per language.
  • We tell users what a model misses as well as what it finds. Software that hides its own failure rate is unsafe in privacy work.
  • Our products check their own output where possible. For example, Solander reads back its redacted file to confirm nothing is still legible.

4. We look for bias and fix what we find

A redaction model that misses names from some cultures more than others protects some people less than others. We treat that as a defect.

  • We test detection rates across name origins, languages, scripts and document types, not only in aggregate.
  • When we find a gap, we record it, fix it in the training data or model, and retest before the next release.
  • We review every model for bias at least once a year, and again whenever its training data changes.

5. We are open about how our software works

Users should be able to understand what our software does with their documents.

  • We publish plain-language descriptions of our methods, models and data sources.
  • Our open-source tools, including Contractex and RAG Assistant for Zotero, can be inspected line by line.
  • Where a feature uses generative AI, we say so in the interface.
  • Every answer from a retrieval tool cites its source passage and page, so users can check it.

6. We respect the sources we learn from

Court records, archives and research papers belong to public institutions and their subjects, not to us.

  • We use data only under the licence that covers it, and only for the purposes that licence allows.
  • We do not make the content of licensed records discoverable on search engines, or available for scraping.
  • We remove records from our datasets when the publisher withdraws or revises them.

7. We represent our results honestly

No dataset is complete, and no model is perfect. We say so.

  • We describe the limits of the data our models were trained on, including what it leaves out.
  • We do not overstate accuracy in marketing. Any figure we publish comes from a documented test.
  • We do not present outputs derived from incomplete data as a full picture of a court, a field or a population.

What we will not build

Some uses of our technology are off the table, whoever asks and whatever they offer to pay.

  • Re-identification. We will not build tools that de-anonymise people in court records or other redacted documents, or combine sources to reveal who an anonymised person is.
  • Profiles of individuals. We will not build tools that profile, score or track named people, including judges, parties, witnesses or lawyers.
  • Judge analytics. We will not rank, rate or predict the decisions of individual judges.
  • Automated legal decisions. We will not build software that gives legal advice without a human professional, or that tells someone whether to pursue legal action.
  • Surveillance. We will not build tools for covert monitoring of people or their communications.
  • Selling data. We will not sell, license or trade user data, or licensed source data, to anyone.

Raising a concern

Anyone can tell us when they think our software, or our conduct, falls short of this code. Email hello@quietsignalslab.com with "Ethics" in the subject line. We reply within 10 working days, and we never penalise anyone, inside or outside the lab, for raising a concern in good faith.

We review this code every year and publish each version on our website, with a note of what changed.