diff --git a/go/analysis/unitchecker/export_test.go b/go/analysis/unitchecker/export_test.go
new file mode 100644
index 0000000..04eacc4
--- /dev/null
+++ b/go/analysis/unitchecker/export_test.go
@@ -0,0 +1,26 @@
+// Copyright 2023 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 unitchecker
+
+import (
+	"go/token"
+	"go/types"
+)
+
+// This file exposes various internal hooks to the separate_test.
+//
+// TODO(adonovan): expose a public API to unitchecker that doesn't
+// rely on details of JSON .cfg files or enshrine I/O decisions or
+// assumptions about how "go vet" locates things. Ideally the new Run
+// function would accept an interface, and a Config file would be just
+// one way--the go vet way--to implement it.
+
+func SetTypeImportExport(
+	MakeTypesImporter func(*Config, *token.FileSet) types.Importer,
+	ExportTypes func(*Config, *token.FileSet, *types.Package) error,
+) {
+	makeTypesImporter = MakeTypesImporter
+	exportTypes = ExportTypes
+}
diff --git a/go/analysis/unitchecker/separate_test.go b/go/analysis/unitchecker/separate_test.go
new file mode 100644
index 0000000..12d9104
--- /dev/null
+++ b/go/analysis/unitchecker/separate_test.go
@@ -0,0 +1,302 @@
+// Copyright 2023 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 unitchecker_test
+
+// This file illustrates separate analysis with an example.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/token"
+	"go/types"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+
+	"golang.org/x/tools/go/analysis/passes/printf"
+	"golang.org/x/tools/go/analysis/unitchecker"
+	"golang.org/x/tools/go/gcexportdata"
+	"golang.org/x/tools/go/packages"
+	"golang.org/x/tools/txtar"
+)
+
+// ExampleSeparateAnalysis demonstrates the principle of separate
+// analysis, the distribution of units of type-checking and analysis
+// work across several processes, using serialized summaries to
+// communicate between them.
+//
+// It uses two different kinds of task, "manager" and "worker":
+//
+//   - The manager computes the graph of package dependencies, and makes
+//     a request to the worker for each package. It does not parse,
+//     type-check, or analyze Go code. It is analogous "go vet".
+//
+//   - The worker, which contains the Analyzers, reads each request,
+//     loads, parses, and type-checks the files of one package,
+//     applies all necessary analyzers to the package, then writes
+//     its results to a file. It is a unitchecker-based driver,
+//     analogous to the program specified by go vet -vettool= flag.
+//
+// In practice these would be separate executables, but for simplicity
+// of this example they are provided by one executable in two
+// different modes: the Example function is the manager, and the same
+// executable invoked with ENTRYPOINT=worker is the worker.
+// (See TestIntegration for how this happens.)
+func ExampleSeparateAnalysis() {
+	// src is an archive containing a module with a printf mistake.
+	const src = `
+-- go.mod --
+module separate
+go 1.18
+
+-- main/main.go --
+package main
+
+import "separate/lib"
+
+func main() {
+	lib.MyPrintf("%s", 123)
+}
+
+-- lib/lib.go --
+package lib
+
+import "fmt"
+
+func MyPrintf(format string, args ...any) {
+	fmt.Printf(format, args...)
+}
+`
+
+	// Expand archive into tmp tree.
+	tmpdir, err := os.MkdirTemp("", "SeparateAnalysis")
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := extractTxtar(txtar.Parse([]byte(src)), tmpdir); err != nil {
+		log.Fatal(err)
+	}
+
+	// Load metadata for the main package and all its dependencies.
+	cfg := &packages.Config{
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedModule,
+		Dir:  tmpdir,
+		Env: append(os.Environ(),
+			"GOPROXY=off", // disable network
+			"GOWORK=off",  // an ambient GOWORK value would break package loading
+		),
+	}
+	pkgs, err := packages.Load(cfg, "separate/main")
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Stop if any package had a metadata error.
+	if packages.PrintErrors(pkgs) > 0 {
+		os.Exit(1)
+	}
+
+	// Now we have loaded the import graph,
+	// let's begin the proper work of the manager.
+
+	// Gather root packages. They will get all analyzers,
+	// whereas dependencies get only the subset that
+	// produce facts or are required by them.
+	roots := make(map[*packages.Package]bool)
+	for _, pkg := range pkgs {
+		roots[pkg] = true
+	}
+
+	// nextID generates sequence numbers for each unit of work.
+	// We use it to create names of temporary files.
+	var nextID atomic.Int32
+
+	// Visit all packages in postorder: dependencies first.
+	// TODO(adonovan): opt: use parallel postorder.
+	packages.Visit(pkgs, nil, func(pkg *packages.Package) {
+		if pkg.PkgPath == "unsafe" {
+			return
+		}
+
+		// Choose a unique prefix for temporary files
+		// (.cfg .types .facts) produced by this package.
+		// We stow it in an otherwise unused field of
+		// Package so it can be accessed by our importers.
+		prefix := fmt.Sprintf("%s/%d", tmpdir, nextID.Add(1))
+		pkg.ExportFile = prefix
+
+		// Construct the request to the worker.
+		var (
+			importMap   = make(map[string]string)
+			packageFile = make(map[string]string)
+			packageVetx = make(map[string]string)
+		)
+		for importPath, dep := range pkg.Imports {
+			importMap[importPath] = dep.PkgPath
+			if depPrefix := dep.ExportFile; depPrefix != "" { // skip "unsafe"
+				packageFile[dep.PkgPath] = depPrefix + ".types"
+				packageVetx[dep.PkgPath] = depPrefix + ".facts"
+			}
+		}
+		cfg := unitchecker.Config{
+			ID:           pkg.ID,
+			ImportPath:   pkg.PkgPath,
+			GoFiles:      pkg.CompiledGoFiles,
+			NonGoFiles:   pkg.OtherFiles,
+			IgnoredFiles: pkg.IgnoredFiles,
+			ImportMap:    importMap,
+			PackageFile:  packageFile,
+			PackageVetx:  packageVetx,
+			VetxOnly:     !roots[pkg],
+			VetxOutput:   prefix + ".facts",
+		}
+		if pkg.Module != nil {
+			if v := pkg.Module.GoVersion; v != "" {
+				cfg.GoVersion = "go" + v
+			}
+		}
+
+		// Write the JSON configuration message to a file.
+		cfgData, err := json.Marshal(cfg)
+		if err != nil {
+			log.Fatal(err)
+		}
+		cfgFile := prefix + ".cfg"
+		if err := os.WriteFile(cfgFile, cfgData, 0666); err != nil {
+			log.Fatal(err)
+		}
+
+		// Send the request to the worker.
+		cmd := exec.Command(os.Args[0], "-json", cfgFile)
+		cmd.Stderr = os.Stderr
+		cmd.Stdout = new(bytes.Buffer)
+		cmd.Env = append(os.Environ(), "ENTRYPOINT=worker")
+		if err := cmd.Run(); err != nil {
+			log.Fatal(err)
+		}
+
+		// Parse JSON output and print plainly.
+		dec := json.NewDecoder(cmd.Stdout.(io.Reader))
+		for {
+			type jsonDiagnostic struct {
+				Posn    string `json:"posn"`
+				Message string `json:"message"`
+			}
+			// 'results' maps Package.Path -> Analyzer.Name -> diagnostics
+			var results map[string]map[string][]jsonDiagnostic
+			if err := dec.Decode(&results); err != nil {
+				if err == io.EOF {
+					break
+				}
+				log.Fatal(err)
+			}
+			for _, result := range results {
+				for analyzer, diags := range result {
+					for _, diag := range diags {
+						rel := strings.ReplaceAll(diag.Posn, tmpdir, "")
+						rel = filepath.ToSlash(rel)
+						fmt.Printf("%s: [%s] %s\n",
+							rel, analyzer, diag.Message)
+					}
+				}
+			}
+		}
+	})
+
+	// Observe that the example produces a fact-based diagnostic
+	// from separate analysis of "main", "lib", and "fmt":
+
+	// Output:
+	// /main/main.go:6:2: [printf] separate/lib.MyPrintf format %s has arg 123 of wrong type int
+}
+
+// -- worker process --
+
+// worker is the main entry point for a unitchecker-based driver
+// with only a single analyzer, for illustration.
+func worker() {
+	// Currently the unitchecker API doesn't allow clients to
+	// control exactly how and where fact and type information
+	// is produced and consumed.
+	//
+	// So, for example, it assumes that type information has
+	// already been produced by the compiler, which is true when
+	// running under "go vet", but isn't necessary. It may be more
+	// convenient and efficient for a distributed analysis system
+	// if the worker generates both of them, which is the approach
+	// taken in this example; they could even be saved as two
+	// sections of a single file.
+	//
+	// Consequently, this test currently needs special access to
+	// private hooks in unitchecker to control how and where facts
+	// and types are produced and consumed. In due course this
+	// will become a respectable public API. In the meantime, it
+	// should at least serve as a demonstration of how one could
+	// fork unitchecker to achieve separate analysis without go vet.
+	unitchecker.SetTypeImportExport(makeTypesImporter, exportTypes)
+
+	unitchecker.Main(printf.Analyzer)
+}
+
+func makeTypesImporter(cfg *unitchecker.Config, fset *token.FileSet) types.Importer {
+	imports := make(map[string]*types.Package)
+	return importerFunc(func(importPath string) (*types.Package, error) {
+		// Resolve import path to package path (vendoring, etc)
+		path, ok := cfg.ImportMap[importPath]
+		if !ok {
+			return nil, fmt.Errorf("can't resolve import %q", path)
+		}
+		if path == "unsafe" {
+			return types.Unsafe, nil
+		}
+
+		// Find, read, and decode file containing type information.
+		file, ok := cfg.PackageFile[path]
+		if !ok {
+			return nil, fmt.Errorf("no package file for %q", path)
+		}
+		f, err := os.Open(file)
+		if err != nil {
+			return nil, err
+		}
+		defer f.Close() // ignore error
+		return gcexportdata.Read(f, fset, imports, path)
+	})
+}
+
+func exportTypes(cfg *unitchecker.Config, fset *token.FileSet, pkg *types.Package) error {
+	var out bytes.Buffer
+	if err := gcexportdata.Write(&out, fset, pkg); err != nil {
+		return err
+	}
+	typesFile := strings.TrimSuffix(cfg.VetxOutput, ".facts") + ".types"
+	return os.WriteFile(typesFile, out.Bytes(), 0666)
+}
+
+// -- helpers --
+
+type importerFunc func(path string) (*types.Package, error)
+
+func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
+
+// extractTxtar writes each archive file to the corresponding location beneath dir.
+//
+// TODO(adonovan): move this to txtar package, we need it all the time (#61386).
+func extractTxtar(ar *txtar.Archive, dir string) error {
+	for _, file := range ar.Files {
+		name := filepath.Join(dir, file.Name)
+		if err := os.MkdirAll(filepath.Dir(name), 0777); err != nil {
+			return err
+		}
+		if err := os.WriteFile(name, file.Data, 0666); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/go/analysis/unitchecker/unitchecker.go b/go/analysis/unitchecker/unitchecker.go
index 88527d7..4ff45fe 100644
--- a/go/analysis/unitchecker/unitchecker.go
+++ b/go/analysis/unitchecker/unitchecker.go
@@ -38,7 +38,6 @@
 	"go/token"
 	"go/types"
 	"io"
-	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
@@ -59,19 +58,19 @@
 // whose name ends with ".cfg".
 type Config struct {
 	ID                        string // e.g. "fmt [fmt.test]"
-	Compiler                  string
-	Dir                       string
-	ImportPath                string
+	Compiler                  string // gc or gccgo, provided to MakeImporter
+	Dir                       string // (unused)
+	ImportPath                string // package path
 	GoVersion                 string // minimum required Go version, such as "go1.21.0"
 	GoFiles                   []string
 	NonGoFiles                []string
 	IgnoredFiles              []string
-	ImportMap                 map[string]string
-	PackageFile               map[string]string
-	Standard                  map[string]bool
-	PackageVetx               map[string]string
-	VetxOnly                  bool
-	VetxOutput                string
+	ImportMap                 map[string]string // maps import path to package path
+	PackageFile               map[string]string // maps package path to file of type information
+	Standard                  map[string]bool   // package belongs to standard library
+	PackageVetx               map[string]string // maps package path to file of fact information
+	VetxOnly                  bool              // run analysis only for facts, not diagnostics
+	VetxOutput                string            // where to write file of fact information
 	SucceedOnTypecheckFailure bool
 }
 
@@ -167,7 +166,7 @@
 }
 
 func readConfig(filename string) (*Config, error) {
-	data, err := ioutil.ReadFile(filename)
+	data, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
@@ -184,6 +183,55 @@
 	return cfg, nil
 }
 
+type factImporter = func(pkgPath string) ([]byte, error)
+
+// These four hook variables are a proof of concept of a future
+// parameterization of a unitchecker API that allows the client to
+// determine how and where facts and types are produced and consumed.
+// (Note that the eventual API will likely be quite different.)
+//
+// The defaults honor a Config in a manner compatible with 'go vet'.
+var (
+	makeTypesImporter = func(cfg *Config, fset *token.FileSet) types.Importer {
+		return importer.ForCompiler(fset, cfg.Compiler, func(importPath string) (io.ReadCloser, error) {
+			// Resolve import path to package path (vendoring, etc)
+			path, ok := cfg.ImportMap[importPath]
+			if !ok {
+				return nil, fmt.Errorf("can't resolve import %q", path)
+			}
+
+			// path is a resolved package path, not an import path.
+			file, ok := cfg.PackageFile[path]
+			if !ok {
+				if cfg.Compiler == "gccgo" && cfg.Standard[path] {
+					return nil, nil // fall back to default gccgo lookup
+				}
+				return nil, fmt.Errorf("no package file for %q", path)
+			}
+			return os.Open(file)
+		})
+	}
+
+	exportTypes = func(*Config, *token.FileSet, *types.Package) error {
+		// By default this is a no-op, because "go vet"
+		// makes the compiler produce type information.
+		return nil
+	}
+
+	makeFactImporter = func(cfg *Config) factImporter {
+		return func(pkgPath string) ([]byte, error) {
+			if vetx, ok := cfg.PackageVetx[pkgPath]; ok {
+				return os.ReadFile(vetx)
+			}
+			return nil, nil // no .vetx file, no facts
+		}
+	}
+
+	exportFacts = func(cfg *Config, data []byte) error {
+		return os.WriteFile(cfg.VetxOutput, data, 0666)
+	}
+)
+
 func run(fset *token.FileSet, cfg *Config, analyzers []*analysis.Analyzer) ([]result, error) {
 	// Load, parse, typecheck.
 	var files []*ast.File
@@ -199,27 +247,9 @@
 		}
 		files = append(files, f)
 	}
-	compilerImporter := importer.ForCompiler(fset, cfg.Compiler, func(path string) (io.ReadCloser, error) {
-		// path is a resolved package path, not an import path.
-		file, ok := cfg.PackageFile[path]
-		if !ok {
-			if cfg.Compiler == "gccgo" && cfg.Standard[path] {
-				return nil, nil // fall back to default gccgo lookup
-			}
-			return nil, fmt.Errorf("no package file for %q", path)
-		}
-		return os.Open(file)
-	})
-	importer := importerFunc(func(importPath string) (*types.Package, error) {
-		path, ok := cfg.ImportMap[importPath] // resolve vendoring, etc
-		if !ok {
-			return nil, fmt.Errorf("can't resolve import %q", path)
-		}
-		return compilerImporter.Import(path)
-	})
 	tc := &types.Config{
-		Importer:  importer,
-		Sizes:     types.SizesFor("gc", build.Default.GOARCH), // assume gccgo ≡ gc?
+		Importer:  makeTypesImporter(cfg, fset),
+		Sizes:     types.SizesFor("gc", build.Default.GOARCH), // TODO(adonovan): use cfg.Compiler
 		GoVersion: cfg.GoVersion,
 	}
 	info := &types.Info{
@@ -288,13 +318,7 @@
 	analyzers = filtered
 
 	// Read facts from imported packages.
-	read := func(pkgPath string) ([]byte, error) {
-		if vetx, ok := cfg.PackageVetx[pkgPath]; ok {
-			return ioutil.ReadFile(vetx)
-		}
-		return nil, nil // no .vetx file, no facts
-	}
-	facts, err := facts.NewDecoder(pkg).Decode(false, read)
+	facts, err := facts.NewDecoder(pkg).Decode(false, makeFactImporter(cfg))
 	if err != nil {
 		return nil, err
 	}
@@ -394,8 +418,11 @@
 	}
 
 	data := facts.Encode(false)
-	if err := ioutil.WriteFile(cfg.VetxOutput, data, 0666); err != nil {
-		return nil, fmt.Errorf("failed to write analysis facts: %v", err)
+	if err := exportFacts(cfg, data); err != nil {
+		return nil, fmt.Errorf("failed to export analysis facts: %v", err)
+	}
+	if err := exportTypes(cfg, fset, pkg); err != nil {
+		return nil, fmt.Errorf("failed to export type information: %v", err)
 	}
 
 	return results, nil
@@ -406,7 +433,3 @@
 	diagnostics []analysis.Diagnostic
 	err         error
 }
-
-type importerFunc func(path string) (*types.Package, error)
-
-func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
diff --git a/go/analysis/unitchecker/unitchecker_test.go b/go/analysis/unitchecker/unitchecker_test.go
index 1ed0012..270a358 100644
--- a/go/analysis/unitchecker/unitchecker_test.go
+++ b/go/analysis/unitchecker/unitchecker_test.go
@@ -29,6 +29,9 @@
 	case "minivet":
 		minivet()
 		panic("unreachable")
+	case "worker":
+		worker() // see ExampleSeparateAnalysis
+		panic("unreachable")
 	}
 
 	// test process