diff --git a/internal/task/gerrit.go b/internal/task/gerrit.go
index ccf5fa4..7874e2b 100644
--- a/internal/task/gerrit.go
+++ b/internal/task/gerrit.go
@@ -19,6 +19,8 @@
 	AwaitSubmit(ctx context.Context, changeID string) (string, error)
 	// Tag creates a tag on project at the specified commit.
 	Tag(ctx context.Context, project, tag, commit string) error
+	// ListTags returns all the tags on project.
+	ListTags(ctx context.Context, project string) ([]string, error)
 }
 
 type realGerritClient struct {
@@ -89,6 +91,18 @@
 	return err
 }
 
+func (c *realGerritClient) ListTags(ctx context.Context, project string) ([]string, error) {
+	tags, err := c.client.GetProjectTags(ctx, project)
+	if err != nil {
+		return nil, err
+	}
+	var tagNames []string
+	for _, tag := range tags {
+		tagNames = append(tagNames, strings.TrimPrefix(tag.Ref, "refs/tags/"))
+	}
+	return tagNames, nil
+}
+
 // changeLink returns a link to the review page for the CL with the specified
 // change ID. The change ID must be in the project~cl# form.
 func changeLink(changeID string) string {
diff --git a/internal/task/milestones.go b/internal/task/milestones.go
index 4601186..f8ac385 100644
--- a/internal/task/milestones.go
+++ b/internal/task/milestones.go
@@ -4,7 +4,6 @@
 	"context"
 	"fmt"
 	"sort"
-	"strconv"
 	"strings"
 
 	"github.com/google/go-github/github"
@@ -76,16 +75,6 @@
 	return ReleaseMilestones{Current: currentMilestone, Next: nextMilestone}, nil
 }
 
-func nextVersion(version string) (string, error) {
-	parts := strings.Split(version, ".")
-	n, err := strconv.Atoi(parts[len(parts)-1])
-	if err != nil {
-		return "", err
-	}
-	parts[len(parts)-1] = strconv.Itoa(n + 1)
-	return strings.Join(parts, "."), nil
-}
-
 func uppercaseVersion(version string) string {
 	return strings.Replace(version, "go", "Go", 1)
 }
diff --git a/internal/task/version.go b/internal/task/version.go
index e83c687..d9f9a20 100644
--- a/internal/task/version.go
+++ b/internal/task/version.go
@@ -2,6 +2,8 @@
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 
 	"golang.org/x/build/gerrit"
 	"golang.org/x/build/internal/workflow"
@@ -13,6 +15,70 @@
 	Project string
 }
 
+type NextVersions struct {
+	CurrentMinor  string
+	PreviousMinor string
+	Beta          string
+	RC            string
+	Major         string
+}
+
+// GetNextVersions returns the next version for each type of release.
+func (t *VersionTasks) GetNextVersions(ctx *workflow.TaskContext) (NextVersions, error) {
+	tags, err := t.Gerrit.ListTags(ctx, t.Project)
+	if err != nil {
+		return NextVersions{}, err
+	}
+	tagSet := map[string]bool{}
+	for _, tag := range tags {
+		tagSet[tag] = true
+	}
+	// Find the most recently released major version.
+	currentMajor := 0
+	for ; ; currentMajor++ {
+		if !tagSet[fmt.Sprintf("go1.%d", currentMajor+1)] {
+			break
+		}
+	}
+	var savedError error
+	findUnused := func(v string) string {
+		for {
+			if !tagSet[v] {
+				return v
+			}
+			var err error
+			v, err = nextVersion(v)
+			if err != nil {
+				savedError = err
+				return ""
+			}
+		}
+	}
+	// Find the next missing tag for each release type.
+	result := NextVersions{
+		CurrentMinor:  findUnused(fmt.Sprintf("go1.%d.1", currentMajor)),
+		PreviousMinor: findUnused(fmt.Sprintf("go1.%d.1", currentMajor-1)),
+		Beta:          findUnused(fmt.Sprintf("go1.%dbeta1", currentMajor+1)),
+		RC:            findUnused(fmt.Sprintf("go1.%drc1", currentMajor+1)),
+		Major:         fmt.Sprintf("go1.%d", currentMajor+1),
+	}
+	return result, savedError
+}
+
+func nextVersion(version string) (string, error) {
+	lastNonDigit := strings.LastIndexFunc(version, func(r rune) bool {
+		return r < '0' || r > '9'
+	})
+	if lastNonDigit == -1 || len(version) == lastNonDigit {
+		return "", fmt.Errorf("malformatted Go version %q", version)
+	}
+	n, err := strconv.Atoi(version[lastNonDigit+1:])
+	if err != nil {
+		return "", fmt.Errorf("malformatted Go version %q (%v)", version, err)
+	}
+	return fmt.Sprintf("%s%d", version[:lastNonDigit+1], n+1), nil
+}
+
 // CreateAutoSubmitVersionCL mails an auto-submit change to update VERSION on branch.
 func (t *VersionTasks) CreateAutoSubmitVersionCL(ctx *workflow.TaskContext, branch, version string) (string, error) {
 	return t.Gerrit.CreateAutoSubmitChange(ctx, gerrit.ChangeInput{
diff --git a/internal/task/version_test.go b/internal/task/version_test.go
index 0880983..6d1fd32 100644
--- a/internal/task/version_test.go
+++ b/internal/task/version_test.go
@@ -6,12 +6,77 @@
 	"strings"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
 	"golang.org/x/build/gerrit"
 	"golang.org/x/build/internal/workflow"
 )
 
 var flagRunVersionTest = flag.Bool("run-version-test", false, "run version test, which will submit CLs to go.googlesource.com/scratch. Must have a Gerrit cookie in gitcookies.")
 
+func TestGetNextVersionsLive(t *testing.T) {
+	if !*flagRunVersionTest {
+		t.Skip("Not enabled by flags")
+	}
+
+	cl := gerrit.NewClient("https://go-review.googlesource.com", gerrit.GitCookiesAuth())
+	tasks := &VersionTasks{
+		Gerrit:  &realGerritClient{client: cl},
+		Project: "go",
+	}
+	ctx := &workflow.TaskContext{
+		Context: context.Background(),
+		Logger:  &testLogger{t},
+	}
+
+	versions, err := tasks.GetNextVersions(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// It's hard to check correctness automatically.
+	t.Errorf("manually verify results: %#v", versions)
+}
+
+func TestGetNextVersions(t *testing.T) {
+	tasks := &VersionTasks{
+		Gerrit: &versionsClient{
+			tags: []string{
+				"go1.1", "go1.2",
+				"go1.3beta1", "go1.3beta2", "go1.3rc1", "go1.3", "go1.3.1", "go1.3.2", "go1.3.3",
+				"go1.4beta1", "go1.4beta2", "go1.4rc1", "go1.4", "go1.4.1",
+				"go1.5beta1", "go1.5rc1",
+			},
+		},
+		Project: "go",
+	}
+	ctx := &workflow.TaskContext{
+		Context: context.Background(),
+		Logger:  &testLogger{t},
+	}
+	versions, err := tasks.GetNextVersions(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := NextVersions{
+		CurrentMinor:  "go1.4.2",
+		PreviousMinor: "go1.3.4",
+		Beta:          "go1.5beta2",
+		RC:            "go1.5rc2",
+		Major:         "go1.5",
+	}
+	if diff := cmp.Diff(versions, want); diff != "" {
+		t.Fatalf("GetNextVersions mismatch (-want +got):\n%s", diff)
+	}
+}
+
+type versionsClient struct {
+	tags []string
+	GerritClient
+}
+
+func (c *versionsClient) ListTags(ctx context.Context, project string) ([]string, error) {
+	return c.tags, nil
+}
+
 func TestVersion(t *testing.T) {
 	if !*flagRunVersionTest {
 		t.Skip("Not enabled by flags")