diff --git a/internal/reviews/gerrit.go b/internal/reviews/gerrit.go
new file mode 100644
index 0000000..d4c57e3
--- /dev/null
+++ b/internal/reviews/gerrit.go
@@ -0,0 +1,158 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reviews
+
+import (
+	"slices"
+	"strconv"
+	"time"
+
+	"golang.org/x/oscar/internal/gerrit"
+)
+
+// GerritReviewClient is a [gerrit.Client] with a mapping
+// from account e-mail addresses to [Account] data.
+// We do things this way because a lot of Gerrit change
+// data is more or less the same for any Gerrit project,
+// but account information is not.
+type GerritReviewClient struct {
+	GClient  *gerrit.Client
+	Project  string
+	Accounts AccountLookup
+}
+
+// GerritChange implements [Change] for a Gerrit CL.
+type GerritChange struct {
+	Client *GerritReviewClient
+	Change *gerrit.Change
+}
+
+// ID returns the change ID.
+func (gc *GerritChange) ID() string {
+	return strconv.Itoa(gc.Client.GClient.ChangeNumber(gc.Change))
+}
+
+// Status returns the change status.
+func (gc *GerritChange) Status() Status {
+	switch gc.Client.GClient.ChangeStatus(gc.Change) {
+	case "MERGED":
+		return StatusSubmitted
+	case "ABANDONED":
+		return StatusClosed
+	default:
+		if gc.Client.GClient.ChangeWorkInProgress(gc.Change) {
+			return StatusDoNotReview
+		}
+		return StatusReady
+	}
+}
+
+// Author returns the change author.
+func (gc *GerritChange) Author() Account {
+	gai := gc.Client.GClient.ChangeOwner(gc.Change)
+	return gc.Client.Accounts.Lookup(gai.Email)
+}
+
+// Created returns the time that the change was created.
+func (gc *GerritChange) Created() time.Time {
+	ct := gc.Client.GClient.ChangeTimes(gc.Change)
+	return ct.Created
+}
+
+// Updated returns the time that the change was last updated.
+func (gc *GerritChange) Updated() time.Time {
+	ct := gc.Client.GClient.ChangeTimes(gc.Change)
+	return ct.Updated
+}
+
+// UpdatedByAuthor returns the time that the change was updated by the
+// original author.
+func (gc *GerritChange) UpdatedByAuthor() time.Time {
+	author := gc.Client.GClient.ChangeOwner(gc.Change)
+	revs := gc.Client.GClient.ChangeRevisions(gc.Change)
+	for _, rev := range slices.Backward(revs) {
+		if rev.Uploader.Email == author.Email {
+			return rev.Created.Time()
+		}
+	}
+	return time.Time{}
+}
+
+// Subject returns the change subject.
+func (gc *GerritChange) Subject() string {
+	return gc.Client.GClient.ChangeSubject(gc.Change)
+}
+
+// Description returns the full change description.
+func (gc *GerritChange) Description() string {
+	return gc.Client.GClient.ChangeDescription(gc.Change)
+}
+
+// Reviewers returns the assigned reviewers.
+func (gc *GerritChange) Reviewers() []Account {
+	reviewers := gc.Client.GClient.ChangeReviewers(gc.Change)
+	ret := make([]Account, 0, len(reviewers))
+	for _, rev := range reviewers {
+		ret = append(ret, gc.Client.Accounts.Lookup(rev.Email))
+	}
+	return ret
+}
+
+// Reviewed returns the accounts that have reviewed the change.
+// We treat any account that has sent a message about the change
+// as a reviewer.
+func (gc *GerritChange) Reviewed() []Account {
+	reviewers := make(map[string]bool)
+	msgs := gc.Client.GClient.ChangeMessages(gc.Change)
+	for _, msg := range msgs {
+		if msg.RealAuthor != nil {
+			reviewers[msg.RealAuthor.Email] = true
+		} else if msg.Author != nil {
+			reviewers[msg.Author.Email] = true
+		}
+	}
+
+	num := gc.Client.GClient.ChangeNumber(gc.Change)
+	commentMap := gc.Client.GClient.Comments(gc.Client.Project, num)
+	for _, comments := range commentMap {
+		for _, comment := range comments {
+			if comment.Author != nil {
+				reviewers[comment.Author.Email] = true
+			}
+		}
+	}
+
+	owner := gc.Client.GClient.ChangeOwner(gc.Change)
+	delete(reviewers, owner.Email)
+
+	ret := make([]Account, 0, len(reviewers))
+	for email := range reviewers {
+		ret = append(ret, gc.Client.Accounts.Lookup(email))
+	}
+	return ret
+}
+
+// Needs returns missing requirements for submittal.
+// This implementation does what we can, but most projects will need
+// their own version of this method.
+func (gc *GerritChange) Needs() Needs {
+	hasReview, hasMaintainerReview := false, false
+	for _, review := range gc.Reviewed() {
+		switch review.Authority() {
+		case AuthorityReviewer:
+			hasReview = true
+		case AuthorityMaintainer, AuthorityOwner:
+			hasMaintainerReview = true
+		}
+	}
+	if hasMaintainerReview {
+		// We don't really know if the change can be submitted.
+		return 0
+	} else if hasReview {
+		return NeedsMaintainerReview
+	} else {
+		return NeedsReview
+	}
+}
diff --git a/internal/reviews/gerrit_test.go b/internal/reviews/gerrit_test.go
new file mode 100644
index 0000000..7f50faa
--- /dev/null
+++ b/internal/reviews/gerrit_test.go
@@ -0,0 +1,196 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reviews
+
+import (
+	"reflect"
+	"slices"
+	"testing"
+	"time"
+
+	"golang.org/x/oscar/internal/gerrit"
+	"golang.org/x/oscar/internal/secret"
+	"golang.org/x/oscar/internal/storage"
+	"golang.org/x/oscar/internal/testutil"
+)
+
+// testGerritClient returns a [*gerrit.Client] for testing.
+func testGerritClient(t *testing.T) *gerrit.Client {
+	lg := testutil.Slogger(t)
+	db := storage.MemDB()
+	sdb := secret.Empty()
+	return gerrit.New("reviews-test", lg, db, sdb, nil)
+}
+
+// loadTestChange loads a txtar file as a [Change].
+func loadTestChange(t *testing.T, gc *gerrit.Client, filename string, num int) Change {
+	tc := gc.Testing()
+	testutil.Check(t, tc.LoadTxtar(filename))
+	gch := gc.Change("test", num)
+	grc := &GerritReviewClient{
+		GClient: gc,
+		Project: "test",
+		Accounts: gerritTestAccountLookup{
+			"gopher@golang.org": &gerritTestAccount{
+				name:        "gopher@golang.org",
+				displayName: "gopher",
+				authority:   AuthorityReviewer,
+				commits:     10,
+			},
+			"maintainer@golang.org": &gerritTestAccount{
+				name:        "maintainer@golang.org",
+				displayName: "maintainer",
+				authority:   AuthorityMaintainer,
+				commits:     10,
+			},
+			"commenter@golang.org": &gerritTestAccount{
+				name:        "commenter@golang.org",
+				displayName: "commenter",
+				authority:   AuthorityContributor,
+				commits:     10,
+			},
+		},
+	}
+	change := &GerritChange{
+		Client: grc,
+		Change: gch,
+	}
+	return change
+}
+
+func TestGerritChange(t *testing.T) {
+	gc := testGerritClient(t)
+	change := loadTestChange(t, gc, "testdata/gerritchange.txt", 1)
+
+	toEmail := func(fn func() []Account) func() []string {
+		return func() []string {
+			var ret []string
+			for _, r := range fn() {
+				ret = append(ret, r.Name())
+			}
+			slices.Sort(ret)
+			return ret
+		}
+	}
+
+	tests := []struct {
+		name   string
+		method func() any
+		want   any
+	}{
+		{
+			"ID",
+			wm(change.ID),
+			"1",
+		},
+		{
+			"Status",
+			wm(change.Status),
+			StatusReady,
+		},
+		{
+			"Author",
+			wm(change.Author().Name),
+			"gopher@golang.org",
+		},
+		{
+			"Created",
+			wm(change.Created),
+			time.Date(2024, 10, 1, 10, 10, 10, 0, time.UTC),
+		},
+		{
+			"Updated",
+			wm(change.Updated),
+			time.Date(2024, 10, 3, 10, 10, 10, 0, time.UTC),
+		},
+		{
+			"UpdatedByAuthor",
+			wm(change.UpdatedByAuthor),
+			time.Date(2024, 10, 2, 10, 10, 10, 0, time.UTC),
+		},
+		{
+			"Subject",
+			wm(change.Subject),
+			"my new change",
+		},
+		{
+			"Description",
+			wm(change.Description),
+			"initial change",
+		},
+		{
+			"Reviewers",
+			wm(toEmail(change.Reviewers)),
+			[]string{
+				"maintainer@golang.org",
+			},
+		},
+		{
+			"Reviewed",
+			wm(toEmail(change.Reviewed)),
+			[]string{
+				"commenter@golang.org",
+				"maintainer@golang.org",
+			},
+		},
+		{
+			"Needs",
+			wm(change.Needs),
+			Needs(0),
+		},
+	}
+
+	for _, test := range tests {
+		got := test.method()
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("%s got %v, want %v", test.name, got, test.want)
+		}
+	}
+}
+
+// changeMethod is one of the methods used to retrieve Change values.
+type changeMethod[T any] func() T
+
+// wm wraps a changeMethod in a function that we can put in a table.
+func wm[T any](fn changeMethod[T]) func() any {
+	return func() any {
+		return fn()
+	}
+}
+
+// gerritTestAccount implements [Account].
+type gerritTestAccount struct {
+	name        string
+	displayName string
+	authority   Authority
+	commits     int
+}
+
+// Name implements Account.Name.
+func (gta *gerritTestAccount) Name() string {
+	return gta.name
+}
+
+// DisplayName implements Account.DisplayName.
+func (gta *gerritTestAccount) DisplayName() string {
+	return gta.displayName
+}
+
+// Authority implements Account.Authority
+func (gta *gerritTestAccount) Authority() Authority {
+	return gta.authority
+}
+
+// Commits implements Account.Commits.
+func (gta *gerritTestAccount) Commits() int {
+	return gta.commits
+}
+
+// gerritTestAccountLookup implements [AccountLookup].
+type gerritTestAccountLookup map[string]Account
+
+func (gtal gerritTestAccountLookup) Lookup(name string) Account {
+	return gtal[name]
+}
diff --git a/internal/reviews/pred.go b/internal/reviews/pred.go
new file mode 100644
index 0000000..9e610e0
--- /dev/null
+++ b/internal/reviews/pred.go
@@ -0,0 +1,208 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reviews
+
+import (
+	"fmt"
+	"sync"
+)
+
+// A Predicate is a categorization of a [Change].
+// An example of a Predicate would be "has been approved by a maintainer"
+// or "author is a known contributor" or
+// "waiting for response from author."
+// The dashboard permits filtering and sorting CLs based on the different
+// predicates they satisfy.
+// A Predicate has a default score that indicates how important it is,
+// but the dashboard permits using different sort orders.
+type Predicate struct {
+	Name        string // a short, one-word name
+	Description string // a longer description
+	Score       int    // default scoring value
+
+	// The Applies function reports whether this Predicate
+	// applies to a change.
+	Applies func(Change) (bool, error)
+}
+
+// ChangePreds is a [Change] with a list of predicates that apply
+// to that change.
+type ChangePreds struct {
+	Change     Change
+	Predicates []*Predicate
+}
+
+// A Reject is like a [Predicate], but if the Reject applies to a [Change]
+// then the Change is not put on the dashboard at all.
+type Reject Predicate
+
+// ApplyPredicates takes a [Change] and applies predicates to it.
+// The bool result reports whether the change is reviewable;
+// this will be false if the change should not be reviewed,
+// for example because it has already been committed.
+func ApplyPredicates(change Change) (ChangePreds, bool, error) {
+	predicatesLock.Lock()
+	// The predicates and rejects slices are append-only,
+	// so a top-level copy is safe to use.
+	p := predicates
+	r := rejects
+	predicatesLock.Unlock()
+
+	for i := range r {
+		applies, err := r[i].Applies(change)
+		if err != nil {
+			return ChangePreds{}, false, err
+		}
+		if applies {
+			return ChangePreds{}, false, nil
+		}
+	}
+
+	var preds []*Predicate
+	for i := range p {
+		pred := &p[i]
+		applies, err := pred.Applies(change)
+		if err != nil {
+			return ChangePreds{}, false, err
+		}
+		if applies {
+			preds = append(preds, pred)
+		}
+	}
+
+	cp := ChangePreds{
+		Change:     change,
+		Predicates: preds,
+	}
+
+	return cp, true, nil
+}
+
+// AddPredicates adds more [Predicate] values for a project.
+func AddPredicates(newPreds []Predicate) {
+	predicatesLock.Lock()
+	defer predicatesLock.Unlock()
+	predicates = append(predicates, newPreds...)
+}
+
+// AddRejects adds more [Reject] values for a project.
+func AddRejects(newRejects []Reject) {
+	predicatesLock.Lock()
+	defer predicatesLock.Unlock()
+	rejects = append(rejects, newRejects...)
+}
+
+// Some [Predicate] default scores.
+const (
+	ScoreImportant     = 10  // change is important
+	ScoreSuggested     = 1   // change is worth looking at
+	ScoreUninteresting = -1  // change is not interesting
+	ScoreUnimportant   = -10 // change is not important
+)
+
+// predicatesLock protects predicates and rejectors.
+var predicatesLock sync.Mutex
+
+// predicates is the list of [Predicate] values that we apply to a change.
+var predicates = []Predicate{
+	{
+		Name:        "authorMaintainer",
+		Description: "the change author is a project maintainer",
+		Score:       ScoreImportant,
+		Applies:     authorMaintainer,
+	},
+	{
+		Name:        "authorReviewer",
+		Description: "the change author is a project reviewer",
+		Score:       ScoreSuggested,
+		Applies:     authorReviewer,
+	},
+	{
+		Name:        "authorContributor",
+		Description: "the change author is a project contributor",
+		Score:       ScoreSuggested,
+		Applies:     authorContributor,
+	},
+	{
+		Name:        "authorMajorContributor",
+		Description: "the change author is a major project contributor",
+		Score:       ScoreImportant,
+		Applies:     authorMajorContributor,
+	},
+	{
+		Name:        "noMaintainerReviews",
+		Description: "has no reviews from a project maintainer",
+		Score:       ScoreSuggested,
+		Applies:     noMaintainerReviews,
+	},
+}
+
+// authorMaintainer is a [Predicate] function that reports whether the
+// [Change] author is a project maintainer.
+func authorMaintainer(ch Change) (bool, error) {
+	switch ch.Author().Authority() {
+	case AuthorityMaintainer, AuthorityOwner:
+		return true, nil
+	default:
+		return false, nil
+	}
+}
+
+// authorReviewer is a [Predicate] function that reports whether the
+// [Change] author is a project reviewer.
+func authorReviewer(ch Change) (bool, error) {
+	switch ch.Author().Authority() {
+	case AuthorityReviewer:
+		return true, nil
+	default:
+		return false, nil
+	}
+}
+
+// authorContributor is a [Predicate] function that reports whether the
+// [Change] author is a known contributor: more than 10 changes contributed.
+func authorContributor(ch Change) (bool, error) {
+	return ch.Author().Commits() > 10, nil
+}
+
+// authorMajorContributor is a [Predicate] function that reports whether the
+// [Change] author is a major contributor: more than 50 changes contributed.
+func authorMajorContributor(ch Change) (bool, error) {
+	return ch.Author().Commits() > 50, nil
+}
+
+// noMaintainerReviews is a [Predicate] function that reports whether the
+// [Change] has not been reviewed by a maintainer.
+func noMaintainerReviews(ch Change) (bool, error) {
+	for _, r := range ch.Reviewed() {
+		switch r.Authority() {
+		case AuthorityMaintainer, AuthorityOwner:
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+// rejects is the list of Reject values that we apply to a change.
+var rejects = []Reject{
+	{
+		Name:        "reviewable",
+		Description: "whether the change is reviewable",
+		Applies:     unreviewable,
+	},
+}
+
+// unreviewable is a [Reject] function that reports whether a
+// [Change] is not reviewable.
+func unreviewable(ch Change) (bool, error) {
+	switch status := ch.Status(); status {
+	case StatusReady:
+		return false, nil
+	case StatusSubmitted, StatusClosed, StatusDoNotReview:
+		return true, nil
+	default:
+		return false, fmt.Errorf("reviewable predicate: change %s: unrecognized status %d", ch.ID(), status)
+	}
+}
diff --git a/internal/reviews/pred_test.go b/internal/reviews/pred_test.go
new file mode 100644
index 0000000..5c13a0c
--- /dev/null
+++ b/internal/reviews/pred_test.go
@@ -0,0 +1,44 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reviews
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestPredicates(t *testing.T) {
+	gc := testGerritClient(t)
+	const file = "testdata/gerritchange.txt"
+	const num = 1
+	change := loadTestChange(t, gc, file, 1)
+	sc, ok, err := ApplyPredicates(change)
+	if err != nil {
+		t.Fatalf("%s: %d: ApplyPredicates returned unexpected error %v", file, num, err)
+	} else if !ok {
+		t.Fatalf("%s: %d: ApplyPredicates unexpectedly rejected change", file, num)
+	}
+	var got []string
+	for _, s := range sc.Predicates {
+		got = append(got, s.Name)
+	}
+	want := []string{"authorReviewer"}
+	if !slices.Equal(got, want) {
+		t.Errorf("%s: %d: got %v, want %v", file, num, got, want)
+	}
+}
+
+func TestReject(t *testing.T) {
+	gc := testGerritClient(t)
+	const file = "testdata/gerritchange.txt"
+	const num = 2
+	change := loadTestChange(t, gc, file, num)
+	_, ok, err := ApplyPredicates(change)
+	if err != nil {
+		t.Fatalf("%s: %d: ApplyPredicates returned unexpected error %v", file, num, err)
+	} else if ok {
+		t.Fatalf("%s: %d: ApplyPredicates unexpectedly accepted change", file, num)
+	}
+}
diff --git a/internal/reviews/reviews.go b/internal/reviews/reviews.go
new file mode 100644
index 0000000..29cfe42
--- /dev/null
+++ b/internal/reviews/reviews.go
@@ -0,0 +1,125 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package reviews contains tools for project maintainers to
+// categorize incoming changes, to help them decide what to
+// review next.
+package reviews
+
+import (
+	"time"
+)
+
+// A Change is a change suggested for a project.
+// This is something like a GitHub pull request or a Gerrit change.
+//
+// For example, users of a Gerrit repo will read data using
+// the gerrit package, and produce a [GerritChange] which implements [Change].
+// They can then use the general purpose scoring algorithms to
+// categorize the changes.
+type Change interface {
+	// The change ID, which is unique for a given project.
+	// This is something like a Git revision or a Gerrit change number.
+	ID() string
+	// The change status.
+	Status() Status
+	// The person or agent who wrote the change.
+	Author() Account
+	// When the change was created.
+	Created() time.Time
+	// When the change was last updated.
+	Updated() time.Time
+	// When the change was last updated by the change author.
+	UpdatedByAuthor() time.Time
+	// The change subject: the first line of the description.
+	Subject() string
+	// The complete change description.
+	Description() string
+	// The list of people whose review is requested.
+	Reviewers() []Account
+	// The list of people who have reviewed the change.
+	Reviewed() []Account
+	// What the change needs in order to be submitted.
+	Needs() Needs
+}
+
+// Status is the status of a change.
+type Status int
+
+const (
+	// Change is ready for review. The default.
+	StatusReady Status = iota
+	// Change is submitted.
+	StatusSubmitted
+	// Change is closed or abandoned.
+	StatusClosed
+	// Change is open but not ready for review.
+	StatusDoNotReview
+)
+
+// Needs is a bitmask of missing requirements for a [Change].
+// The requirements may not be comprehensive; it's possible that
+// when all these requirements are satisfied there will be more.
+// If the Needs value is 0 then the change can be submitted.
+type Needs int
+
+const (
+	// Change needs a review by someone.
+	NeedsReview Needs = 1 << iota
+	// Change needs to be approved.
+	NeedsApproval
+	// Change needs maintainer review,
+	// but not necessarily approval.
+	NeedsMaintainerReview
+	// Change needs to resolve a reviewer comment.
+	NeedsResolve
+	// Change needs to resolve a merge conflict.
+	NeedsConflictResolve
+	// Change waiting for tests or other checks to pass.
+	NeedsCheck
+	// Some reviewer has this change on hold,
+	// or change is marked as do not submit by author.
+	NeedsHoldRemoval
+	// Change waiting for next release to open.
+	NeedsRelease
+	// Change not submittable for some other reason.
+	NeedsOther
+)
+
+// An Account describes a person or agent.
+type Account interface {
+	// The unique account name, such as an e-mail address.
+	Name() string
+	// The display name of the account, such as a person's full name.
+	DisplayName() string
+	// The authority of this account in the project.
+	Authority() Authority
+	// Number of commits made by this account to the project.
+	Commits() int
+}
+
+// AccountLookup looks up account information by name.
+// If there is no such account, this returns nil.
+// At least for Gerrit, account information is stored
+// differently by different Gerrit instances,
+// so we need an interface.
+type AccountLookup interface {
+	Lookup(string) Account
+}
+
+// Authority describes what authority a person has in a project.
+type Authority int
+
+const (
+	// Person is unknown or has no particular status.
+	AuthorityUnknown Authority = iota
+	// Person has contributed changes.
+	AuthorityContributor
+	// Person has reviewed changes.
+	AuthorityReviewer
+	// Person is a maintainer who can review and commit patches by others.
+	AuthorityMaintainer
+	// Person is a project owner/admin.
+	AuthorityOwner
+)
diff --git a/internal/reviews/testdata/gerritchange.txt b/internal/reviews/testdata/gerritchange.txt
new file mode 100644
index 0000000..cb17bb9
--- /dev/null
+++ b/internal/reviews/testdata/gerritchange.txt
@@ -0,0 +1,41 @@
+-- change#1 --
+Number: 1
+Project: test
+Status: NEW
+Owner: gopher@golang.org
+Created: "2024-10-01 10:10:10.00000000"
+Updated: "2024-10-03 10:10:10.00000000"
+Subject: my new change
+CurrentRevision: hash2
+CurrentRevisionNumber: 2
+Revisions: hash1
+ Kind: REWORK
+ Number: 1
+ Created: "2024-10-01 10:10:10.00000000"
+ Uploader: gopher@golang.org
+ Commit:
+  Message: initial change
+Revisions: hash2
+ Kind: REWORK
+ Number: 2
+ Created: "2024-10-02 10:10:10.00000000"
+ Uploader: gopher@golang.org
+ Commit:
+  Message: initial change
+Reviewers: REVIEWER
+ AccountID: 1000
+ Email: maintainer@golang.org
+Messages:
+ ID: message hash 1
+ Author: maintainer@golang.org
+ Date: "2024-10-01 11:10:10.00000000"
+ Message: "maintainer review"
+Messages:
+ ID: message hash 2
+ Author: commenter@golang.org
+ Date: "2024-10-01 12:10:10.00000000"
+ Message: "commenter review"
+-- change#2 --
+Number: 2
+Project: test
+Status: MERGED