diff --git a/README.md b/README.md
index 0227c413..06286393 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,10 @@ This design removes the need for any sort of server-side setup. As a result,
 this tool can work with any git hosting provider, and the only setup required
 is installing the client on your workstation.
 
+Additionally, code reviews can be conducted across multiple hosting providers.
+The list of forks of a repository is also stored in the repository as git
+objects, allowing code reviews to be pulled from every registered fork.
+
 ## Installation
 
 Assuming you have the [Go tools installed](https://golang.org/doc/install), run
@@ -80,8 +84,15 @@ Submitting the current review:
 
     git appraise submit [--merge | --rebase]
 
+Adding a fork:
+
+    git appraise fork add -o <contributor-email>[,<contributor-email>]* <name> <url>
+
 A more detailed getting started doc is available [here](docs/tutorial.md).
 
+Instructions for using `git-appraise` with multiple forks can be found
+[here](docs/forks.md).
+
 ## Metadata
 
 The code review data is stored in [git-notes](https://git-scm.com/docs/git-notes),
diff --git a/commands/commands.go b/commands/commands.go
index 75b8c72d..b4ea0390 100644
--- a/commands/commands.go
+++ b/commands/commands.go
@@ -18,12 +18,17 @@ limitations under the License.
 package commands
 
 import (
+	"fmt"
+
 	"github.com/google/git-appraise/repository"
 )
 
-const notesRefPattern = "refs/notes/devtools/*"
-const archiveRefPattern = "refs/devtools/archives/*"
-const commentFilename = "APPRAISE_COMMENT_EDITMSG"
+const (
+	notesRefPattern    = "refs/notes/devtools/*"
+	devtoolsRefPattern = "refs/devtools/*"
+	archiveRefPattern  = "refs/devtools/archives/*"
+	commentFilename    = "APPRAISE_COMMENT_EDITMSG"
+)
 
 // Command represents the definition of a single command.
 type Command struct {
@@ -41,15 +46,41 @@ func (cmd *Command) Run(repo repository.Repo, args []string) error {
 
 // CommandMap defines all of the available (sub)commands.
 var CommandMap = map[string]*Command{
-	"abandon": abandonCmd,
-	"accept":  acceptCmd,
-	"comment": commentCmd,
-	"list":    listCmd,
-	"pull":    pullCmd,
-	"push":    pushCmd,
-	"rebase":  rebaseCmd,
-	"reject":  rejectCmd,
-	"request": requestCmd,
-	"show":    showCmd,
-	"submit":  submitCmd,
+	"abandon":     abandonCmd,
+	"accept":      acceptCmd,
+	"comment":     commentCmd,
+	"fork add":    addForkCmd,
+	"fork list":   listForksCmd,
+	"fork remove": removeForkCmd,
+	"list":        listCmd,
+	"pull":        pullCmd,
+	"push":        pushCmd,
+	"rebase":      rebaseCmd,
+	"reject":      rejectCmd,
+	"request":     requestCmd,
+	"show":        showCmd,
+	"submit":      submitCmd,
+}
+
+// FindSubcommand parses the subcommand from the list of arguments.
+//
+// The args parameter is the list of command line args after the program name.
+//
+// The return result are the matching command (if found), whether or not the
+// command was found, and the list of remaining command line arguments that
+// followed the subcommand.
+func FindSubcommand(args []string) (*Command, bool, []string) {
+	if len(args) < 1 {
+		subcommand, ok := CommandMap["list"]
+		return subcommand, ok, []string{}
+	}
+	subcommand, ok := CommandMap[args[0]]
+	if ok {
+		return subcommand, ok, args[1:]
+	}
+	if len(args) > 1 {
+		subcommand, ok := CommandMap[fmt.Sprintf("%s %s", args[0], args[1])]
+		return subcommand, ok, args[2:]
+	}
+	return nil, false, []string{}
 }
diff --git a/commands/commands_test.go b/commands/commands_test.go
new file mode 100644
index 00000000..7bb527da
--- /dev/null
+++ b/commands/commands_test.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package commands
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFindSubcommandBuiltins(t *testing.T) {
+	for name, cmd := range CommandMap {
+		additionalArg := "foo"
+		matchingArgs := append(strings.Split(name, " "), additionalArg)
+		subcommand, ok, remainingArgs := FindSubcommand(matchingArgs)
+		if !ok {
+			t.Errorf("Failed to find the built-in subcommand %q", name)
+		} else if subcommand != cmd {
+			t.Errorf("Return the wrong subcommand for %q", name)
+		} else if len(remainingArgs) != 1 || remainingArgs[0] != additionalArg {
+			t.Errorf("Failed to return the remaining arguments for %q", name)
+		}
+	}
+}
+
+func TestFindSubcommandEmpty(t *testing.T) {
+	subcommand, ok, remaining := FindSubcommand([]string{})
+	if !ok {
+		t.Fatalf("Failed to return a default subcommand")
+	}
+	if subcommand != CommandMap["list"] {
+		t.Fatalf("Failed to return `list` as the default subcommand")
+	}
+	if len(remaining) != 0 {
+		t.Fatalf("Unexpected remaining arguments for an empty command: %q", remaining)
+	}
+}
diff --git a/commands/fork.go b/commands/fork.go
new file mode 100644
index 00000000..7eac438c
--- /dev/null
+++ b/commands/fork.go
@@ -0,0 +1,111 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package commands
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/google/git-appraise/commands/output"
+	"github.com/google/git-appraise/fork"
+	"github.com/google/git-appraise/repository"
+)
+
+var (
+	addForkFlagSet = flag.NewFlagSet("fork add", flag.ExitOnError)
+	addForkOwners  = addForkFlagSet.String("o", "", "Comma-separated list of owner email addresses")
+)
+
+// addFork updates the local git repository to include the specified fork.
+func addFork(repo repository.Repo, args []string) error {
+	addForkFlagSet.Parse(args)
+	args = addForkFlagSet.Args()
+
+	var owners []string
+	if len(*addForkOwners) > 0 {
+		for _, owner := range strings.Split(*addForkOwners, ",") {
+			owners = append(owners, strings.TrimSpace(owner))
+		}
+	}
+	if len(args) < 2 {
+		return errors.New("The name and URL of the fork must be specified.")
+	}
+	if len(args) > 2 {
+		return errors.New("Only the name and URL of the fork may be specified.")
+	}
+	if len(owners) == 0 {
+		return errors.New("You must specify at least one owner.")
+	}
+	name := args[0]
+	url := args[1]
+	return fork.Add(repo, fork.New(name, url, owners))
+}
+
+// listForks lists the forks registered in the local git repository.
+func listForks(repo repository.Repo, args []string) error {
+	forks, err := fork.List(repo)
+	if err != nil {
+		return err
+	}
+	output.PrintForks(forks)
+	return nil
+}
+
+// removeFork updates the local git repository to no longer include the specified fork.
+func removeFork(repo repository.Repo, args []string) error {
+	if len(args) < 1 {
+		return errors.New("The name of the fork must be specified.")
+	}
+	if len(args) > 1 {
+		return errors.New("Only the name of the fork may be specified.")
+	}
+	name := args[0]
+	return fork.Delete(repo, name)
+}
+
+// addForkCmd defines the `fork add` command.
+var addForkCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork add [<option>...] <name> <url>\n\nOptions:\n", arg0)
+		addForkFlagSet.PrintDefaults()
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return addFork(repo, args)
+	},
+}
+
+// listForksCmd defines the `fork add` command.
+var listForksCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork list\n", arg0)
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return listForks(repo, args)
+	},
+}
+
+// removeForkCmd defines the `fork add` command.
+var removeForkCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s fork remove <name>\n", arg0)
+	},
+	RunMethod: func(repo repository.Repo, args []string) error {
+		return removeFork(repo, args)
+	},
+}
diff --git a/commands/output/output.go b/commands/output/output.go
index bc0c993f..3d09537b 100644
--- a/commands/output/output.go
+++ b/commands/output/output.go
@@ -23,6 +23,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/git-appraise/fork"
 	"github.com/google/git-appraise/repository"
 	"github.com/google/git-appraise/review"
 )
@@ -61,6 +62,14 @@ status: %s
 `
 	// Number of lines of context to print for inline comments
 	contextLineCount = 5
+	// Template for printing the summary of the forks.
+	forksSummaryTemplate = `%d forks
+`
+	// Template for printing the summary of a code review.
+	forkTemplate = `%q
+  owners: %q
+  urls: %q
+`
 )
 
 // getStatusString returns a human friendly string encapsulating both the review's
@@ -256,3 +265,11 @@ func PrintDiff(r *review.Review, diffArgs ...string) error {
 	fmt.Println(diff)
 	return nil
 }
+
+// PrintForks prints the list of forks.
+func PrintForks(forks []*fork.Fork) {
+	fmt.Printf(forksSummaryTemplate, len(forks))
+	for _, f := range forks {
+		fmt.Printf(forkTemplate, f.Name, f.Owners, f.URLS)
+	}
+}
diff --git a/commands/pull.go b/commands/pull.go
index 809c20fd..fb7ac1d0 100644
--- a/commands/pull.go
+++ b/commands/pull.go
@@ -21,6 +21,7 @@ import (
 	"flag"
 	"fmt"
 
+	"github.com/google/git-appraise/fork"
 	"github.com/google/git-appraise/repository"
 	"github.com/google/git-appraise/review"
 )
@@ -29,6 +30,7 @@ var (
 	pullFlagSet = flag.NewFlagSet("pull", flag.ExitOnError)
 	pullVerify  = pullFlagSet.Bool("verify-signatures", false,
 		"verify the signatures of pulled reviews")
+	pullIncludeForks = pullFlagSet.Bool("include-forks", true, "Also pull reviews and comments from forks.")
 )
 
 // pull updates the local git-notes used for reviews with those from a remote
@@ -38,26 +40,28 @@ func pull(repo repository.Repo, args []string) error {
 	pullArgs := pullFlagSet.Args()
 
 	if len(pullArgs) > 1 {
-		return errors.New(
-			"Only pulling from one remote at a time is supported.")
+		return errors.New("Only pulling from one remote at a time is supported.")
 	}
 
 	remote := "origin"
 	if len(pullArgs) == 1 {
 		remote = pullArgs[0]
 	}
-	// This is the easy case. We're not checking signatures so just go the
-	// normal route.
+
+	if !*pullVerify && !*pullIncludeForks {
+		return repo.PullNotesAndArchive(remote, notesRefPattern, archiveRefPattern)
+	}
 	if !*pullVerify {
-		return repo.PullNotesAndArchive(remote, notesRefPattern,
-			archiveRefPattern)
+		if _, err := repo.PullNotesForksAndArchive(remote, notesRefPattern, fork.Ref, archiveRefPattern); err != nil {
+			return fmt.Errorf("failure pulling review metadata from the remote %q: %v", remote, err)
+		}
+		return fork.Pull(repo, *pullVerify)
 	}
 
-	// Otherwise, we collect the fetched reviewed revisions (their hashes), get
+	// We collect the fetched reviewed revisions (their hashes), get
 	// their reviews, and then one by one, verify them. If we make it through
 	// the set, _then_ we merge the remote reference into the local branch.
-	revisions, err := repo.FetchAndReturnNewReviewHashes(remote,
-		notesRefPattern, archiveRefPattern)
+	revisions, err := repo.FetchAndReturnNewReviewHashes(remote, notesRefPattern, archiveRefPattern)
 	if err != nil {
 		return err
 	}
@@ -74,17 +78,24 @@ func pull(repo repository.Repo, args []string) error {
 		}
 		fmt.Println("verified review:", revision)
 	}
-
-	err = repo.MergeNotes(remote, notesRefPattern)
-	if err != nil {
+	if err := repo.MergeNotes(remote, notesRefPattern); err != nil {
+		return err
+	}
+	if err := repo.MergeArchives(remote, archiveRefPattern); err != nil {
+		return err
+	}
+	if !*pullIncludeForks {
+		return nil
+	}
+	if err := repo.MergeForks(remote, fork.Ref); err != nil {
 		return err
 	}
-	return repo.MergeArchives(remote, archiveRefPattern)
+	return fork.Pull(repo, *pullVerify)
 }
 
 var pullCmd = &Command{
 	Usage: func(arg0 string) {
-		fmt.Printf("Usage: %s pull [<option>] [<remote>]\n\nOptions:\n", arg0)
+		fmt.Printf("Usage: %s pull [<option>...] [<remote>]\n\nOptions:\n", arg0)
 		pullFlagSet.PrintDefaults()
 	},
 	RunMethod: func(repo repository.Repo, args []string) error {
diff --git a/commands/push.go b/commands/push.go
index c75a25ea..4f6e96e6 100644
--- a/commands/push.go
+++ b/commands/push.go
@@ -19,6 +19,7 @@ package commands
 import (
 	"errors"
 	"fmt"
+
 	"github.com/google/git-appraise/repository"
 )
 
@@ -33,10 +34,9 @@ func push(repo repository.Repo, args []string) error {
 		remote = args[0]
 	}
 
-	if err := repo.PushNotesAndArchive(remote, notesRefPattern, archiveRefPattern); err != nil {
-		return err
-	}
-	return nil
+	notesRefspec := fmt.Sprintf("%s:%s", notesRefPattern, notesRefPattern)
+	devtoolsRefspec := fmt.Sprintf("+%s*:%s*", devtoolsRefPattern, devtoolsRefPattern)
+	return repo.Push(remote, notesRefspec, devtoolsRefspec)
 }
 
 var pushCmd = &Command{
diff --git a/docs/forks.md b/docs/forks.md
new file mode 100644
index 00000000..0feb5c8b
--- /dev/null
+++ b/docs/forks.md
@@ -0,0 +1,69 @@
+# Working with multiple forks
+
+This file documents how to use `git-appraise` with contributors who do not have
+permission to push to the main repository.
+
+In this model, each contributor sets up their own personal fork of the
+repository. They then push to their fork instead of the main repository.
+
+The list of these forks is stored inside the repository itself, in a special
+ref. The tool uses that list to pull changes and reviews from all the
+registered forks.
+
+## Adding a fork
+
+The owner of the main repository can add a fork with the following command,
+followed by `git appraise push`:
+
+```shell
+git appraise fork add -o <contributor-email>[,<contributor-email>]* <name> <url>
+```
+
+## Using a fork to request a review
+
+The owner of a fork can request reviews for any branches they create as long as
+the following rules hold:
+
+1. The name of the branch is prefixed with the name of their fork.
+2. The committer email field of the commit to be reviewed matches
+   one of the owner email addresses of the fork.
+
+To request the review, run the usual `git appraise request ...` command, and
+then use `git appraise push ...` to push it to the fork.
+
+## Using a fork to comment on reviews
+
+The owner of a fork can comment on any code review. The only requirement is
+that the email address they use for git is listed as one of the owner email
+addresses for the fork.
+
+## Pulling code reviews from forks
+
+When running `git appraise pull`, the tool will automatically fetch and merge
+reviews from the forks. This behavior can be controlled using the
+`--include-forks` flag. Alternatively, it can be configured on a
+per-remote basis using the `appraise.remote.<remote>.includeForks` setting.
+
+## Dealing with abusive fork owners
+
+If the owner of a fork is acting inappropriately, both the owner of the main
+repository and the cloners of that repository have tools to exclude reviews and
+comments from that abusive owner's fork:
+
+### Removing a fork
+
+The owner of the main repository can remove a fork by running the following
+command, followed by `git appraise push`:
+
+```shell
+git appraise fork remove <name>
+```
+
+### Excluding a specific fork
+
+Anyone who runs `git appraise pull --include-forks` can configure a list of
+forks to be excluded from the pull. This is controlled by the config settings
+`appraise.remote.<remote>.excludeFork` and `appraise.excludeFork`. The first
+operates on a per-remote basis while the second applies to every remote.
+
+Either option can be configured with either the fork name or URL.
diff --git a/docs/tutorial.md b/docs/tutorial.md
index 6f95bb7e..f2548863 100644
--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -402,3 +402,12 @@ Now that our feature branch has been merged into master, we can delete it:
 git branch -d ${USER}/getting-started
 git push origin --delete ${USER}/getting-started
 ```
+
+# Working with external contributors
+
+The simple workflow above shows how to use `git-appraise` in a single
+repository. However, in practice you do not want to share a single repository
+with every contributor.
+
+Instead, `git-appraise` supports the concept of "forks". Instructions on how to
+use `git-appraise` with multiple forks can be found [here](forks.md)
diff --git a/fork/fork.go b/fork/fork.go
new file mode 100644
index 00000000..cd23b456
--- /dev/null
+++ b/fork/fork.go
@@ -0,0 +1,658 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package fork contains the data structures used to represent repository forks.
+//
+// Forks are stored in a special ref `refs/devtools/forks`, with a tree that
+// contains one subtree per fork named based on the hash of the fork's name.
+//
+// For example, if there is a fork named "omar", then it will have a SHA1 hash
+// of "728d67f71db99d4768351e8e7807bfdd1807eadb", and be stored under the
+// subtree named "7/2/8d67f71db99d4768351e8e7807bfdd1807eadb".
+//
+// Each fork subtree will contain one file named "NAME" and three directories
+// named "URLS", "OWNERS", and "REFS".
+package fork
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"strings"
+
+	"github.com/google/git-appraise/repository"
+	"github.com/google/git-appraise/review/comment"
+	"github.com/google/git-appraise/review/gpg"
+	"github.com/google/git-appraise/review/request"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	Ref = "refs/devtools/forks"
+
+	nameFilePath  = "NAME"
+	ownersDirPath = "OWNERS"
+	refsDirPath   = "REFS"
+	urlsDirPath   = "URLS"
+)
+
+type Fork struct {
+	Name   string   `json:"name,omitempty"`
+	URLS   []string `json:"urls,omitempty"`
+	Owners []string `json:"owners,omitempty"`
+	Refs   []string `json:"refs,omitempty"`
+}
+
+func New(name, url string, owners []string) *Fork {
+	return &Fork{
+		Name:   name,
+		URLS:   []string{url},
+		Owners: owners,
+		Refs: []string{
+			fmt.Sprintf("refs/heads/%s/*", name),
+			"refs/devtools/*",
+			"refs/notes/devtools/*",
+		},
+	}
+}
+
+func localRefForFork(remoteRef, forkName string) (string, error) {
+	if strings.Contains(remoteRef, ":") || strings.Contains(remoteRef, "+") {
+		return "", fmt.Errorf("invalid remote ref %q", remoteRef)
+	}
+	if strings.HasPrefix(remoteRef, "refs/notes/") {
+		// Older versions of git require all notes refs to be under "refs/notes"
+		return fmt.Sprintf("refs/notes/forks/%s/%s", forkName, remoteRef), nil
+	}
+	return fmt.Sprintf("refs/forks/%s/%s", forkName, remoteRef), nil
+}
+
+func filteredRefForFork(remoteRef, forkName string) (string, error) {
+	if strings.Contains(remoteRef, ":") || strings.Contains(remoteRef, "+") {
+		return "", fmt.Errorf("invalid remote ref %q", remoteRef)
+	}
+	if !strings.HasPrefix(remoteRef, "refs/notes/devtools/") {
+		return "", fmt.Errorf("only devtools notes refs can be filtered")
+	}
+	return fmt.Sprintf("refs/notes/filteredForks/%s/%s", forkName, remoteRef), nil
+}
+
+func forkPathFromName(forkName string) []string {
+	forkHash := fmt.Sprintf("%x", sha1.Sum([]byte(forkName)))
+	return []string{forkHash[0:1], forkHash[1:2], forkHash[2:]}
+}
+
+func forkPath(fork *Fork) []string {
+	return forkPathFromName(fork.Name)
+}
+
+func encodeListAsHashedFiles(items []string) *repository.Tree {
+	contents := make(map[string]repository.TreeChild)
+	for _, item := range items {
+		blob := repository.NewBlob(item)
+		path := fmt.Sprintf("%x", sha1.Sum([]byte(item)))
+		contents[path] = blob
+	}
+	return repository.NewTree(contents)
+}
+
+func addNestedTree(parent *repository.Tree, descendant repository.TreeChild, path []string) *repository.Tree {
+	if len(path) == 0 {
+		return parent
+	}
+	var contents map[string]repository.TreeChild
+	if parent == nil {
+		contents = make(map[string]repository.TreeChild)
+	} else {
+		contents = parent.Contents()
+	}
+
+	if len(path) == 1 {
+		contents[path[0]] = descendant
+		return repository.NewTree(contents)
+	}
+
+	childName := path[0]
+	childPath := path[0:1]
+	nestedPath := path[1:]
+	var childTree *repository.Tree
+	childObj, ok := contents[childName]
+	if ok {
+		childTree, ok = childObj.(*repository.Tree)
+		if !ok {
+			// One of the intermediary path components points
+			// at a BLOB, so we are overwriting it.
+			childTree = nil
+		}
+	}
+	childTree = addNestedTree(childTree, descendant, nestedPath)
+	return addNestedTree(parent, childTree, childPath)
+}
+
+// Add adds the given fork to the repository, replacing any existing forks with the same name.
+func Add(repo repository.Repo, fork *Fork) error {
+	contents := make(map[string]repository.TreeChild)
+	contents[nameFilePath] = repository.NewBlob(fork.Name)
+	contents[urlsDirPath] = encodeListAsHashedFiles(fork.URLS)
+	contents[ownersDirPath] = encodeListAsHashedFiles(fork.Owners)
+	contents[refsDirPath] = encodeListAsHashedFiles(fork.Refs)
+	newForkTree := repository.NewTree(contents)
+
+	var previousCommitHash string
+	var forksTree *repository.Tree
+	if hasRef, err := repo.HasRef(Ref); err != nil {
+		return fmt.Errorf("failure checking the existence of the forks ref: %v", err)
+	} else if hasRef {
+		previousCommitHash, err = repo.GetCommitHash(Ref)
+		if err != nil {
+			return fmt.Errorf("failure reading the forks ref commit: %v", err)
+		}
+		forksTree, err = repo.ReadTree(previousCommitHash)
+		if err != nil {
+			return fmt.Errorf("failure reading the forks ref: %v", err)
+		}
+	}
+
+	path := forkPath(fork)
+	forksTree = addNestedTree(forksTree, newForkTree, path)
+	var commitParents []string
+	if previousCommitHash != "" {
+		commitParents = append(commitParents, previousCommitHash)
+	}
+	commitDetails := &repository.CommitDetails{
+		Summary: fmt.Sprintf("Adding the fork: %q", fork.Name),
+		Parents: commitParents,
+	}
+	commitHash, err := repo.CreateCommitWithTree(commitDetails, forksTree)
+	if err != nil {
+		return fmt.Errorf("failure creating a commit to add the fork %q", fork.Name)
+	}
+	return repo.SetRef(Ref, commitHash, previousCommitHash)
+}
+
+// Delete deletes the given fork from the repository.
+func Delete(repo repository.Repo, name string) error {
+	if hasRef, err := repo.HasRef(Ref); err != nil {
+		return fmt.Errorf("failure checking the existence of the forks ref: %v", err)
+	} else if !hasRef {
+		return fmt.Errorf("the specified fork, %q, does not exist", name)
+	}
+	previousCommitHash, err := repo.GetCommitHash(Ref)
+	if err != nil {
+		return fmt.Errorf("failure reading the forks ref commit: %v", err)
+	}
+	forksTree, err := repo.ReadTree(previousCommitHash)
+	if err != nil {
+		return fmt.Errorf("failure reading the forks ref: %v", err)
+	}
+
+	currentLevel := forksTree
+	path := forkPathFromName(name)
+	for len(path) > 1 {
+		childName := path[0]
+		path = path[1:]
+		childObj, ok := currentLevel.Contents()[childName]
+		if !ok {
+			return fmt.Errorf("the specified fork, %q, does not exist", name)
+		}
+		childTree, ok := childObj.(*repository.Tree)
+		if !ok {
+			return fmt.Errorf("the specified fork, %q, does not exist", name)
+		}
+		currentLevel = childTree
+	}
+	delete(currentLevel.Contents(), path[0])
+	commitDetails := &repository.CommitDetails{
+		Summary: fmt.Sprintf("Deleting the fork: %q", name),
+		Parents: []string{previousCommitHash},
+	}
+	commitHash, err := repo.CreateCommitWithTree(commitDetails, forksTree)
+	if err != nil {
+		return fmt.Errorf("failure creating a commit to delete the fork %q", name)
+	}
+	return repo.SetRef(Ref, commitHash, previousCommitHash)
+}
+
+func readHashedFiles(t *repository.Tree) []string {
+	var results []string
+	for path, obj := range t.Contents() {
+		blob, ok := obj.(*repository.Blob)
+		if !ok {
+			// we are not interested in subdirectories
+			continue
+		}
+		contents := blob.Contents()
+		hash := fmt.Sprintf("%x", sha1.Sum([]byte(contents)))
+		if path != hash {
+			// we are not interested in non-hash-named files
+			continue
+		}
+		results = append(results, contents)
+	}
+	return results
+}
+
+func parseForkTree(t *repository.Tree) (*Fork, error) {
+	contents := t.Contents()
+	nameFile, ok := contents[nameFilePath]
+	if !ok {
+		return nil, fmt.Errorf("fork missing a NAME file")
+	}
+	nameBlob, ok := nameFile.(*repository.Blob)
+	if !ok {
+		return nil, fmt.Errorf("fork NAME file is not actually a file")
+	}
+	ownersFile, ok := contents[ownersDirPath]
+	if !ok {
+		return nil, fmt.Errorf("fork missing an OWNERS subdirectory")
+	}
+	ownersDir, ok := ownersFile.(*repository.Tree)
+	if !ok {
+		return nil, fmt.Errorf("fork OWNERS subdirectory is not actually a directory")
+	}
+	refsFile, ok := contents[refsDirPath]
+	if !ok {
+		return nil, fmt.Errorf("fork missing a REFS subdirectory")
+	}
+	refsDir, ok := refsFile.(*repository.Tree)
+	if !ok {
+		return nil, fmt.Errorf("fork REFS subdirectory is not actually a directory")
+	}
+	urlsFile, ok := contents[urlsDirPath]
+	if !ok {
+		return nil, fmt.Errorf("fork missing a URLS subdirectory")
+	}
+	urlsDir, ok := urlsFile.(*repository.Tree)
+	if !ok {
+		return nil, fmt.Errorf("fork URLS subdirectory is not actually a directory")
+	}
+	fork := &Fork{
+		Name:   nameBlob.Contents(),
+		Owners: readHashedFiles(ownersDir),
+		Refs:   readHashedFiles(refsDir),
+		URLS:   readHashedFiles(urlsDir),
+	}
+	return fork, nil
+}
+
+// Flatten the given number of levels of the specified tree.
+//
+// The resulting value is a map from paths in the tree to the nested tree
+// at each path, and is stored in the `results` parameter.
+//
+// Any child objects that are not subtrees at the specified level are ignored.
+func flattenTree(t *repository.Tree, levelsToFlatten int, pathPrefix string, results map[string]*repository.Tree) {
+	if levelsToFlatten < 1 {
+		results[pathPrefix] = t
+		return
+	}
+	for path, obj := range t.Contents() {
+		childTree, ok := obj.(*repository.Tree)
+		if !ok {
+			continue
+		}
+		flattenTree(childTree, levelsToFlatten-1, pathPrefix+path, results)
+	}
+}
+
+// List lists the forks recorded in the repository.
+func List(repo repository.Repo) ([]*Fork, error) {
+	hasForks, err := repo.HasRef(Ref)
+	if err != nil {
+		return nil, err
+	}
+	if !hasForks {
+		return nil, nil
+	}
+	forksTree, err := repo.ReadTree(Ref)
+	if err != nil {
+		return nil, err
+	}
+	forkTrees := make(map[string]*repository.Tree)
+	flattenTree(forksTree, 3, "", forkTrees)
+	forkHashesMap := make(map[string]*Fork)
+	for forkPath, forkTree := range forkTrees {
+		fork, err := parseForkTree(forkTree)
+		if err != nil {
+			continue
+		}
+		forkHashesMap[forkPath] = fork
+	}
+	var forks []*Fork
+	for _, fork := range forkHashesMap {
+		forks = append(forks, fork)
+	}
+	return forks, nil
+}
+
+func (fork *Fork) isOwner(email string) bool {
+	for _, owner := range fork.Owners {
+		if owner == email {
+			return true
+		}
+	}
+	return false
+}
+
+func createMergeCommit(repo repository.Repo, ref, message string, commitsToMerge ...string) error {
+	refCommit, err := repo.GetCommitHash(ref)
+	if err != nil {
+		return fmt.Errorf("failure reading the commit for the ref %q: %v", ref, err)
+	}
+	refDetails, err := repo.GetCommitDetails(refCommit)
+	if err != nil {
+		return fmt.Errorf("failure reading the commit %q: %v", refCommit, err)
+	}
+	parents := append([]string{refCommit}, commitsToMerge...)
+	commitDetails := &repository.CommitDetails{
+		Parents: parents,
+		Summary: message,
+		Tree:    refDetails.Tree,
+	}
+	mergeCommit, err := repo.CreateCommit(commitDetails)
+	if err != nil {
+		return fmt.Errorf("failure creating a merge commit for %q: %v", ref, err)
+	}
+	return repo.SetRef(ref, mergeCommit, refCommit)
+}
+
+func filterNewNotes(repo repository.Repo, destinationRef, sourceRef string, allow func(obj string, note repository.Note) (bool, error)) (map[string][]repository.Note, error) {
+	sourceNotesMap, err := repo.GetAllNotes(sourceRef)
+	if err != nil {
+		return nil, err
+	}
+	if len(sourceNotesMap) == 0 {
+		return nil, nil
+	}
+	existingNoteHashesMap := make(map[string]map[string]struct{})
+	destinationNotesMap, err := repo.GetAllNotes(destinationRef)
+	if err == nil {
+		// Assume the opposite just means the destination ref does not exist
+		for obj, notes := range destinationNotesMap {
+			existingNoteHashes := make(map[string]struct{})
+			existingNoteHashesMap[obj] = existingNoteHashes
+			for _, note := range notes {
+				existingNoteHashes[note.Hash()] = struct{}{}
+			}
+		}
+	}
+	newNotesMap := make(map[string][]repository.Note)
+	for obj, objNotes := range sourceNotesMap {
+		if existingNoteHashes, ok := existingNoteHashesMap[obj]; ok {
+			var newNotes []repository.Note
+			for _, note := range objNotes {
+				if len(note) == 0 {
+					continue
+				}
+				if _, ok := existingNoteHashes[note.Hash()]; ok {
+					continue
+				}
+				newNotes = append(newNotes, note)
+			}
+			objNotes = newNotes
+		}
+		var filteredNotes []repository.Note
+		for _, note := range objNotes {
+			if allow == nil {
+				filteredNotes = append(filteredNotes, note)
+			} else if isAllowed, err := allow(obj, note); err != nil {
+				return nil, err
+			} else if isAllowed {
+				filteredNotes = append(filteredNotes, note)
+			}
+		}
+		if len(filteredNotes) > 0 {
+			newNotesMap[obj] = filteredNotes
+		}
+
+	}
+	return newNotesMap, nil
+}
+
+func mergeNewFilteredNotes(repo repository.Repo, destinationRef, sourceRef, mergeMessage string, allow func(obj string, note repository.Note) (bool, error)) error {
+	sourceCommit, err := repo.GetCommitHash(sourceRef)
+	if err != nil {
+		// There are no notes to merge
+		return nil
+	}
+	parentCommits := []string{sourceCommit}
+	destinationCommit, err := repo.GetCommitHash(destinationRef)
+	if err == nil {
+		if isAncestor, err := repo.IsAncestor(sourceCommit, destinationCommit); err != nil {
+			return err
+		} else if isAncestor {
+			// The notes have already been merged
+			return nil
+		}
+	}
+	notesToAddMap, err := filterNewNotes(repo, destinationRef, sourceRef, allow)
+	if err != nil {
+		return err
+	}
+	if len(notesToAddMap) == 0 {
+		return nil
+	}
+	for obj, notesToAdd := range notesToAddMap {
+		combinedNote := combineNotes(notesToAdd)
+		if err := repo.AppendNote(destinationRef, obj, combinedNote); err != nil {
+			return fmt.Errorf("failure merging in new notes to the ref %q: %v", destinationRef, err)
+		}
+	}
+	return createMergeCommit(repo, destinationRef, mergeMessage, parentCommits...)
+}
+
+func (fork *Fork) filterOwnerRequests(repo repository.Repo, verifySignatures bool) error {
+	forkRequestsRef, err := localRefForFork(request.Ref, fork.Name)
+	if err != nil {
+		return err
+	}
+	filteredForkRequestsRef, err := filteredRefForFork(request.Ref, fork.Name)
+	if err != nil {
+		return err
+	}
+	return mergeNewFilteredNotes(repo, filteredForkRequestsRef, forkRequestsRef,
+		fmt.Sprintf("merging in requests from the fork %q", fork.Name),
+		func(obj string, note repository.Note) (bool, error) {
+			commitDetails, err := repo.GetCommitDetails(obj)
+			if err != nil {
+				// Ignore requests for unknown commits
+				return false, nil
+			}
+			if !fork.isOwner(commitDetails.CommitterEmail) {
+				// Ignore requests to review someone else's commit
+				return false, nil
+			}
+			r, err := request.Parse(note)
+			if err != nil {
+				return false, nil
+			}
+			if !fork.isOwner(r.Requester) {
+				return false, nil
+			}
+			if !verifySignatures {
+				return true, nil
+			}
+			if err := gpg.Verify(&r); err != nil {
+				// Ignore requests that do not have a verified signature
+				return false, nil
+			}
+			return true, nil
+		})
+}
+
+func (fork *Fork) filterOwnerComments(repo repository.Repo, verifySignatures bool) error {
+	forkCommentsRef, err := localRefForFork(comment.Ref, fork.Name)
+	if err != nil {
+		return err
+	}
+	filteredForkCommentsRef, err := filteredRefForFork(comment.Ref, fork.Name)
+	if err != nil {
+		return err
+	}
+	return mergeNewFilteredNotes(repo, filteredForkCommentsRef, forkCommentsRef,
+		fmt.Sprintf("merging in comments from the fork %q", fork.Name),
+		func(obj string, note repository.Note) (bool, error) {
+			c, err := comment.Parse(note)
+			if err != nil {
+				return false, nil
+			}
+			if c.Original != "" {
+				// Ignore comment edits.
+				// TODO(ojarjur): Also support pulling comment edits from forks
+				return false, nil
+			}
+			if !fork.isOwner(c.Author) {
+				// Ignore comments that aren't from the repository owner.
+				return false, nil
+			}
+			if c.Location != nil && c.Location.Check(repo) != nil {
+				// Ignore comments at non-existant locations.
+				return false, nil
+			}
+			if !verifySignatures {
+				return true, nil
+			}
+			if err := gpg.Verify(&c); err != nil {
+				// Ignore comments that do not have a verified signature
+				return false, nil
+			}
+			return true, nil
+		})
+}
+
+func combineNotes(notes []repository.Note) repository.Note {
+	var noteStrings []string
+	for _, note := range notes {
+		noteStrings = append(noteStrings, string(note))
+	}
+	return repository.Note([]byte(strings.Join(noteStrings, "\n")))
+}
+
+func appendAllNotes(repo repository.Repo, destination string, sources ...string) error {
+	for _, source := range sources {
+		mergeMessage := fmt.Sprintf("merging in filtered notes from the ref %q", source)
+		if err := mergeNewFilteredNotes(repo, destination, source, mergeMessage, nil); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (fork *Fork) Fetch(repo repository.Repo, verifySignatures bool) (bool, error) {
+	initialHash, err := repo.GetRepoStateHash()
+	if err != nil {
+		return false, err
+	}
+	for _, url := range fork.URLS {
+		var refSpecs []string
+		for _, ref := range fork.Refs {
+			localRef, err := localRefForFork(ref, fork.Name)
+			if err != nil {
+				return false, err
+			}
+			refSpec := fmt.Sprintf("+%s:%s", ref, localRef)
+			refSpecs = append(refSpecs, refSpec)
+		}
+		if err := repo.Fetch(url, refSpecs...); err != nil {
+			return false, fmt.Errorf("failure fetching from the fork: %v", err)
+		}
+		if updatedHash, err := repo.GetRepoStateHash(); err != nil {
+			return false, err
+		} else if updatedHash == initialHash {
+			continue
+		}
+		var g errgroup.Group
+		g.Go(func() error {
+			if err := fork.filterOwnerRequests(repo, verifySignatures); err != nil {
+				return fmt.Errorf("failure merging the review requests: %v", err)
+			}
+			return nil
+		})
+		g.Go(func() error {
+			if err := fork.filterOwnerComments(repo, verifySignatures); err != nil {
+				return fmt.Errorf("failure merging the comments: %v", err)
+			}
+			return nil
+		})
+		if err := g.Wait(); err != nil {
+			return false, err
+		}
+	}
+	updatedHash, err := repo.GetRepoStateHash()
+	if err != nil {
+		return false, err
+	}
+	return updatedHash != initialHash, nil
+}
+
+func MergeAll(repo repository.Repo, forks []*Fork) error {
+	var filteredForkCommentsRefs []string
+	var filteredForkRequestsRefs []string
+	for _, f := range forks {
+		filteredForkCommentsRef, err := filteredRefForFork(comment.Ref, f.Name)
+		if err != nil {
+			return err
+		}
+		filteredForkRequestsRef, err := filteredRefForFork(request.Ref, f.Name)
+		if err != nil {
+			return err
+		}
+		filteredForkCommentsRefs = append(filteredForkCommentsRefs, filteredForkCommentsRef)
+		filteredForkRequestsRefs = append(filteredForkRequestsRefs, filteredForkRequestsRef)
+	}
+	if err := appendAllNotes(repo, comment.Ref, filteredForkCommentsRefs...); err != nil {
+		return err
+	}
+	if err := appendAllNotes(repo, request.Ref, filteredForkRequestsRefs...); err != nil {
+		return err
+	}
+	return nil
+}
+
+func Pull(repo repository.Repo, verifySignatures bool) error {
+	forks, err := List(repo)
+	if err != nil {
+		return fmt.Errorf("failure listing the forks: %v", err)
+	}
+	var g errgroup.Group
+	newlyFetchedForksChan := make(chan *Fork, len(forks))
+	for _, f := range forks {
+		func(f *Fork) {
+			g.Go(func() error {
+				if newData, err := f.Fetch(repo, verifySignatures); err != nil {
+					return fmt.Errorf("failure pulling from the fork %q: %v", f.Name, err)
+				} else if newData {
+					newlyFetchedForksChan <- f
+				}
+				return nil
+			})
+		}(f)
+	}
+	if err := g.Wait(); err != nil {
+		return err
+	}
+	close(newlyFetchedForksChan)
+	if len(newlyFetchedForksChan) == 0 {
+		return nil
+	}
+	var forksWithNewData []*Fork
+	for f := range newlyFetchedForksChan {
+		forksWithNewData = append(forksWithNewData, f)
+	}
+	if err := MergeAll(repo, forksWithNewData); err != nil {
+		return fmt.Errorf("failure merging from the forks: %v", err)
+	}
+	return nil
+}
diff --git a/fork/fork_test.go b/fork/fork_test.go
new file mode 100644
index 00000000..6126ec09
--- /dev/null
+++ b/fork/fork_test.go
@@ -0,0 +1,182 @@
+/*
+Copyright 2018 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fork
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const (
+	localUserName  = "Local Git User For Test"
+	localUserEmail = "test-local-user@example.com"
+	forkUserName   = "Fork Git User For Test"
+	forkUserEmail  = "test-fork-user@example.com"
+)
+
+func createTestRepository(remoteRepo string) (string, error) {
+	dir, err := ioutil.TempDir("", "test-git-repo")
+	if err != nil {
+		return "", err
+	}
+	if len(remoteRepo) > 0 {
+		parentDir := filepath.Dir(dir)
+		if _, err := runGitCommandInRepo(parentDir, []string{"clone", remoteRepo, dir}); err != nil {
+			return "", fmt.Errorf("Failed to clone the remote test repo %q: %v", remoteRepo, err)
+		}
+		return dir, nil
+	}
+	initCmd := exec.Command("git", "init")
+	initCmd.Dir = dir
+	err = initCmd.Run()
+	if err != nil {
+		os.RemoveAll(dir)
+		return "", err
+	}
+	return dir, nil
+}
+
+func runGitCommandInRepo(repo string, args []string) (string, error) {
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("failed to run the git command %v. Stdout: %q, Stderr: %q, Error: %v", args, stdout.String(), stderr.String(), err)
+	}
+	return stdout.String(), nil
+}
+
+type testFork struct {
+	Name  string
+	User  string
+	Email string
+	Dir   string
+}
+
+func newTestFork(remoteRepo, forkName string) (f *testFork, err error) {
+	forkUser := fmt.Sprintf("Test user for %s", forkName)
+	forkEmail := fmt.Sprintf("%s-owner@example.com", forkName)
+	dir, err := createTestRepository(remoteRepo)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err != nil {
+			os.RemoveAll(dir)
+		}
+	}()
+	if _, err := runGitCommandInRepo(dir, []string{"config", "--local", "--add", "user.name", forkUser}); err != nil {
+		return nil, fmt.Errorf("Failed to set the git user name for the test fork repo %q: %v", forkName, err)
+	}
+	if _, err := runGitCommandInRepo(dir, []string{"config", "--local", "--add", "user.email", forkEmail}); err != nil {
+		return nil, fmt.Errorf("Failed to set the git user email for the test fork repo %q: %v", forkName, err)
+	}
+	if _, err := runGitCommandInRepo(remoteRepo, []string{"appraise", "fork", "add", "-o", forkEmail, forkName, dir}); err != nil {
+		return nil, fmt.Errorf("Failed to add the fork repo %q as a fork: %v", forkName, err)
+	}
+	return &testFork{
+		Name:  forkName,
+		User:  forkUser,
+		Email: forkEmail,
+		Dir:   dir,
+	}, nil
+}
+
+func (f *testFork) Remove() error {
+	return os.RemoveAll(f.Dir)
+}
+
+func (f *testFork) WriteFile(filename, contents string) error {
+	return ioutil.WriteFile(filepath.Join(f.Dir, filename), []byte(contents), 0644)
+}
+
+func (f *testFork) RunGitCommand(args ...string) (string, error) {
+	return runGitCommandInRepo(f.Dir, args)
+}
+
+func TestPullingFromForks(t *testing.T) {
+	remoteRepo, err := createTestRepository("")
+	if err != nil {
+		t.Fatalf("Failed to create the test remote repository: %v", err)
+	}
+	defer os.RemoveAll(remoteRepo)
+	if err := ioutil.WriteFile(filepath.Join(remoteRepo, "README.md"), []byte("# Test Repository"), 0644); err != nil {
+		t.Fatalf("Failed to initialize the contents of the test remote repo: %v", err)
+	}
+	if _, err := runGitCommandInRepo(remoteRepo, []string{"add", "README.md"}); err != nil {
+		t.Fatalf("Failed to add the initial contents of the test remote repo: %v", err)
+	}
+	if _, err := runGitCommandInRepo(remoteRepo, []string{"commit", "-a", "-m", "Initial commit"}); err != nil {
+		t.Fatalf("Failed to commit the initial contents of the test remote repo: %v", err)
+	}
+
+	localRepo, err := newTestFork(remoteRepo, "local")
+	if err != nil {
+		t.Fatalf("Failed to create the test local repository: %v", err)
+	}
+	defer localRepo.Remove()
+
+	for i := 0; i < 10; i++ {
+		forkName := fmt.Sprintf("fork-%d", i)
+		forkRepo, err := newTestFork(remoteRepo, forkName)
+		if err != nil {
+			t.Fatalf("Failed to create the test fork repository %q: %v", forkName, err)
+		}
+		defer forkRepo.Remove()
+		forkBranch := fmt.Sprintf("%s/test-branch", forkName)
+		if _, err := forkRepo.RunGitCommand("checkout", "-b", forkBranch); err != nil {
+			t.Fatalf("Failed to checkout the feature branch of the test fork %q: %v", forkName, err)
+		}
+		if err := forkRepo.WriteFile("Fork.md", fmt.Sprintf("# File written from the fork %q", forkName)); err != nil {
+			t.Fatalf("Failed to initialize the contents of the test fork repo %q feature branch: %v", forkName, err)
+		}
+		if _, err := forkRepo.RunGitCommand("add", "Fork.md"); err != nil {
+			t.Fatalf("Failed to add the contents of the feature branch of the test fork repo: %v", err)
+		}
+		if _, err := forkRepo.RunGitCommand("commit", "-a", "-m", fmt.Sprintf("Add a file from the fork %q", forkName)); err != nil {
+			t.Fatalf("Failed to commit the feature branch of the test fork repo: %v", err)
+		}
+		if _, err := forkRepo.RunGitCommand("appraise", "request"); err != nil {
+			t.Fatalf("Failed to create the review request in the fork repo: %v", err)
+		}
+		if _, err := forkRepo.RunGitCommand("appraise", "pull", "origin"); err != nil {
+			t.Fatalf("Failed to pull the review metadata into the fork repo: %v", err)
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		if _, err := localRepo.RunGitCommand("appraise", "pull", "origin"); err != nil {
+			t.Fatalf("Failed to pull the review metadata from the remote: %v", err)
+		}
+		if listed, err := localRepo.RunGitCommand("appraise", "list"); err != nil {
+			t.Errorf("Error listing the open reviews: %v", err)
+		} else if len(listed) == 0 {
+			t.Errorf("Failed to list the open reviews")
+		} else if !strings.Contains(listed, "Loaded 10 open reviews") {
+			t.Errorf("Unexpected result from listing the open reviews from forks: %q", listed)
+		}
+	}
+}
diff --git a/git-appraise/git-appraise.go b/git-appraise/git-appraise.go
index ca5a30cf..5667eb45 100644
--- a/git-appraise/git-appraise.go
+++ b/git-appraise/git-appraise.go
@@ -58,9 +58,9 @@ func help() {
 		usage()
 		return
 	}
-	subcommand, ok := commands.CommandMap[os.Args[2]]
+	subcommand, ok, _ := commands.FindSubcommand(os.Args[2:])
 	if !ok {
-		fmt.Printf("Unknown command %q\n", os.Args[2])
+		fmt.Printf("Unknown command %q\n", os.Args[2:])
 		usage()
 		return
 	}
@@ -82,22 +82,13 @@ func main() {
 		fmt.Printf("%s must be run from within a git repo.\n", os.Args[0])
 		return
 	}
-	if len(os.Args) < 2 {
-		subcommand, ok := commands.CommandMap["list"]
-		if !ok {
-			fmt.Printf("Unable to list reviews")
-			return
-		}
-		subcommand.Run(repo, []string{})
-		return
-	}
-	subcommand, ok := commands.CommandMap[os.Args[1]]
+	subcommand, ok, remainingArgs := commands.FindSubcommand(os.Args[1:])
 	if !ok {
 		fmt.Printf("Unknown command: %q\n", os.Args[1])
 		usage()
 		return
 	}
-	if err := subcommand.Run(repo, os.Args[2:]); err != nil {
+	if err := subcommand.Run(repo, remainingArgs); err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)
 	}
diff --git a/repository/git.go b/repository/git.go
index c2ea0959..43f55f2e 100644
--- a/repository/git.go
+++ b/repository/git.go
@@ -24,6 +24,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"sort"
@@ -1195,6 +1196,90 @@ func (repo *GitRepo) PullNotesAndArchive(remote, notesRefPattern, archiveRefPatt
 	return nil
 }
 
+// MergeForks merges in the remote's state of the forks reference
+// into the local repository's.
+func (repo *GitRepo) MergeForks(remote, forksRef string) error {
+	remoteRef := getRemoteDevtoolsRef(remote, forksRef)
+	hasRemote, err := repo.HasRef(remoteRef)
+	if err != nil {
+		return err
+	}
+	if !hasRemote {
+		// There are no remote forks to merge
+		return nil
+	}
+	hasLocal, err := repo.HasRef(forksRef)
+	if err != nil {
+		return err
+	}
+	if !hasLocal {
+		// The local forks commit does not exist, so we merely need to set it
+		_, err := repo.runGitCommand("update-ref", forksRef, remoteRef)
+		return err
+	}
+
+	dir, err := ioutil.TempDir("", "merge-forks-dir")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(dir)
+	if _, err := repo.runGitCommand("worktree", "add", dir, forksRef); err != nil {
+		return err
+	}
+	defer func() {
+		repo.runGitCommand("worktree", "remove", "--force", dir)
+	}()
+
+	workTreeRepo := &GitRepo{
+		Path: dir,
+	}
+	if _, err := workTreeRepo.runGitCommand("merge", "--commit", "--allow-unrelated-histories", "--no-edit", "-s", "recursive", "-X", "ours", remoteRef); err != nil {
+		return err
+	}
+	if _, err := workTreeRepo.runGitCommand("update-ref", forksRef, "HEAD"); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PullNotesForksAndArchive fetches the contents of the notes, forks, and archives
+// refs from  a remote repo, and merges them with the corresponding local refs.
+//
+// For notes refs, we assume that every note can be automatically merged using
+// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+// so we automatically merge the remote notes into the local notes.
+//
+// For the forks ref, we assume that we can merge using the recursive, `ours`,
+// merge strategy.
+//
+// For "archive" refs, they are expected to be used solely for maintaining
+// reachability of commits that are part of the history of any reviews,
+// so we do not maintain any consistency with their tree objects. Instead,
+// we merely ensure that their history graph includes every commit that we
+// intend to keep.
+//
+// The returned slice contains a list of all objects for which new notes were
+// fetched from the remote.
+func (repo *GitRepo) PullNotesForksAndArchive(remote, notesRefPattern, forksRef, archiveRefPattern string) ([]string, error) {
+	if !strings.HasPrefix(forksRef, devtoolsRefPrefix) {
+		return nil, fmt.Errorf("Unsupported forks ref: %q", forksRef)
+	}
+	reviews, err := repo.FetchAndReturnNewReviewHashes(remote, notesRefPattern, archiveRefPattern)
+	if err != nil {
+		return nil, fmt.Errorf("failure fetching from the remote %q: %v", remote, err)
+	}
+	if err := repo.MergeArchives(remote, archiveRefPattern); err != nil {
+		return nil, fmt.Errorf("failure merging archives from the remote %q: %v", remote, err)
+	}
+	if err := repo.MergeNotes(remote, notesRefPattern); err != nil {
+		return nil, fmt.Errorf("failure merging notes from the remote %q: %v", remote, err)
+	}
+	if err := repo.MergeForks(remote, forksRef); err != nil {
+		return nil, fmt.Errorf("failure merging forks from the remote %q, %v", remote, err)
+	}
+	return reviews, nil
+}
+
 // Push pushes the given refs to a remote repo.
 func (repo *GitRepo) Push(remote string, refSpecs ...string) error {
 	pushArgs := append([]string{"push", remote}, refSpecs...)
diff --git a/repository/mock_repo.go b/repository/mock_repo.go
index e86da813..d6db680c 100644
--- a/repository/mock_repo.go
+++ b/repository/mock_repo.go
@@ -652,6 +652,12 @@ func (r *mockRepoForTest) MergeArchives(remote, archiveRefPattern string) error
 	return nil
 }
 
+// MergeForks merges in the remote's state of the forks reference
+// into the local repository's.
+func (r *mockRepoForTest) MergeForks(remote, forksRef string) error {
+	return nil
+}
+
 // FetchAndReturnNewReviewHashes fetches the notes "branches" and then susses
 // out the IDs (the revision the review points to) of any new reviews, then
 // returns that list of IDs.
@@ -663,6 +669,25 @@ func (r *mockRepoForTest) FetchAndReturnNewReviewHashes(remote, notesRefPattern
 	return nil, nil
 }
 
+// PullNotesForksAndArchive fetches the contents of the notes, forks, and archives
+// refs from  a remote repo, and merges them with the corresponding local refs.
+//
+// For notes refs, we assume that every note can be automatically merged using
+// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+// so we automatically merge the remote notes into the local notes.
+//
+// For the forks ref, we assume that we can merge using the recursive, `ours`,
+// merge strategy.
+//
+// For "archive" refs, they are expected to be used solely for maintaining
+// reachability of commits that are part of the history of any reviews,
+// so we do not maintain any consistency with their tree objects. Instead,
+// we merely ensure that their history graph includes every commit that we
+// intend to keep.
+func (r *mockRepoForTest) PullNotesForksAndArchive(remote, notesRefPattern, forksRef, archiveRefPattern string) ([]string, error) {
+	return nil, nil
+}
+
 // Push pushes the given refs to a remote repo.
 func (r *mockRepoForTest) Push(remote string, refPattern ...string) error {
 	return nil
diff --git a/repository/repo.go b/repository/repo.go
index c27d6ec9..8fd9912e 100644
--- a/repository/repo.go
+++ b/repository/repo.go
@@ -348,6 +348,10 @@ type Repo interface {
 	// into the local repository's.
 	MergeArchives(remote, archiveRefPattern string) error
 
+	// MergeForks merges in the remote's state of the forks reference
+	// into the local repository's.
+	MergeForks(remote, forksRef string) error
+
 	// FetchAndReturnNewReviewHashes fetches the notes "branches" and then
 	// susses out the IDs (the revision the review points to) of any new
 	// reviews, then returns that list of IDs.
@@ -357,6 +361,26 @@ type Repo interface {
 	// they point to.
 	FetchAndReturnNewReviewHashes(remote, notesRefPattern string, devtoolsRefPatterns ...string) ([]string, error)
 
+	// PullNotesForksAndArchive fetches the contents of the notes, forks, and archives
+	// refs from  a remote repo, and merges them with the corresponding local refs.
+	//
+	// For notes refs, we assume that every note can be automatically merged using
+	// the 'cat_sort_uniq' strategy (the git-appraise schemas fit that requirement),
+	// so we automatically merge the remote notes into the local notes.
+	//
+	// For the forks ref, we assume that we can merge using the recursive, `ours`,
+	// merge strategy.
+	//
+	// For "archive" refs, they are expected to be used solely for maintaining
+	// reachability of commits that are part of the history of any reviews,
+	// so we do not maintain any consistency with their tree objects. Instead,
+	// we merely ensure that their history graph includes every commit that we
+	// intend to keep.
+	//
+	// The returned slice contains a list of all objects for which new notes were
+	// fetched from the remote.
+	PullNotesForksAndArchive(remote, notesRefPattern, forksRef, archiveRefPattern string) ([]string, error)
+
 	// Push pushes the given refs to a remote repo.
 	Push(remote string, refPattern ...string) error
 }
diff --git a/review/review.go b/review/review.go
index 72809c9c..31c26ce9 100644
--- a/review/review.go
+++ b/review/review.go
@@ -22,6 +22,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/google/git-appraise/repository"
 	"github.com/google/git-appraise/review/analyses"
@@ -609,6 +610,57 @@ func (r *Summary) getStartingCommit() string {
 	return r.Revision
 }
 
+// LocalReviewRef finds the local ref that most closely matches the review ref.
+//
+// For refs outside of refs/heads/ (i.e. non-branches), the local ref has to
+// match the review ref exactly.
+//
+// For branches, the following are checked in order:
+// 1. An exact match in the local branches.
+// 2. A matching branch in the `origin` remote.
+// 3. A matching branch in one of the other remotes, checked in alphabetical order.
+// 4. A matching branch in a matching fork (e.g. if the branch starts with "somefork/", then look under "refs/forks/somefork/refs/heads/somefork/...").
+func (r *Review) LocalReviewRef() (string, error) {
+	if !strings.HasPrefix(r.Request.ReviewRef, "refs/heads/") {
+		return r.Request.ReviewRef, nil
+	}
+	if hasRef, err := r.Repo.HasRef(r.Request.ReviewRef); err != nil {
+		return "", err
+	} else if hasRef {
+		return r.Request.ReviewRef, nil
+	}
+	branchName := strings.TrimPrefix(r.Request.ReviewRef, "refs/heads/")
+	originBranch := "refs/remotes/origin/" + branchName
+	if hasRef, err := r.Repo.HasRef(originBranch); err != nil {
+		return "", err
+	} else if hasRef {
+		return originBranch, nil
+	}
+	remotes, err := r.Repo.Remotes()
+	if err != nil {
+		return "", err
+	}
+	for _, remote := range remotes {
+		remoteBranch := "refs/remotes/" + remote + "/" + branchName
+		if hasRef, err := r.Repo.HasRef(remoteBranch); err != nil {
+			return "", err
+		} else if hasRef {
+			return remoteBranch, nil
+		}
+	}
+	if strings.Index(branchName, "/") <= 0 {
+		return r.Request.ReviewRef, nil
+	}
+	forkName := branchName[0:strings.Index(branchName, "/")]
+	forkBranch := "refs/forks/" + forkName + "/refs/heads/" + branchName
+	if hasRef, err := r.Repo.HasRef(forkBranch); err != nil {
+		return "", err
+	} else if hasRef {
+		return forkBranch, nil
+	}
+	return r.Request.ReviewRef, nil
+}
+
 // GetHeadCommit returns the latest commit in a review.
 func (r *Review) GetHeadCommit() (string, error) {
 	currentCommit := r.getStartingCommit()
@@ -625,12 +677,16 @@ func (r *Review) GetHeadCommit() (string, error) {
 	// It is possible that the review ref is no longer an ancestor of the starting
 	// commit (e.g. if a rebase left us in a detached head), in which case we have to
 	// find the head commit without using it.
-	useReviewRef, err := r.Repo.IsAncestor(currentCommit, r.Request.ReviewRef)
+	reviewRef, err := r.LocalReviewRef()
+	if err != nil {
+		return "", err
+	}
+	useReviewRef, err := r.Repo.IsAncestor(currentCommit, reviewRef)
 	if err != nil {
 		return "", err
 	}
 	if useReviewRef {
-		return r.Repo.ResolveRefCommit(r.Request.ReviewRef)
+		return r.Repo.ResolveRefCommit(reviewRef)
 	}
 
 	return r.findLastCommit(currentCommit, currentCommit, r.Comments), nil