diff --git a/core/sequences/collection.go b/core/sequences/collection.go
index 974352da18..50358e026d 100644
--- a/core/sequences/collection.go
+++ b/core/sequences/collection.go
@@ -18,18 +18,25 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"iter"
 	"math"
 	"sort"
 	"strings"
 
 	"github.com/cockroachdb/errors"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/globalstate/sequences"
 	"github.com/dolthub/dolt/go/store/hash"
 	"github.com/dolthub/dolt/go/store/prolly"
 	"github.com/dolthub/dolt/go/store/prolly/tree"
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/types"
 
 	"github.com/dolthub/doltgresql/core/id"
 	"github.com/dolthub/doltgresql/core/rootobject/objinterface"
+	"github.com/dolthub/doltgresql/utils"
 )
 
 // Collection contains a collection of sequences.
@@ -48,11 +55,8 @@ const (
 	Persistence_Unlogged  Persistence = 2
 )
 
-// Sequence represents a single sequence within the pg_sequence table.
-type Sequence struct {
+type SequenceState struct {
 	Id            id.Sequence
-	DataTypeID    id.Type
-	Persistence   Persistence
 	Start         int64
 	Current       int64
 	Increment     int64
@@ -62,13 +66,172 @@ type Sequence struct {
 	Cycle         bool
 	IsAtEnd       bool
 	HasBeenCalled bool
-	OwnerTable    id.Table
-	OwnerColumn   string
+}
+
+type SequenceTracker = dsess.SequenceTracker[*Sequence, SequenceState, int64]
+
+// SequenceTrackerKey is the key to identify the SequenceTracker in the globalstate.GlobalState
+var SequenceTrackerKey dsess.TrackerKey[*SequenceTracker] = struct{}{}
+
+func (sequence SequenceState) Merge(otherSequenceState SequenceState) (merged SequenceState) {
+	newSequenceState := sequence
+	thisIsIncrementing := sequence.Increment > 0
+	otherIsIncrementing := otherSequenceState.Increment > 0
+	if thisIsIncrementing != otherIsIncrementing {
+		// These states can't be merged.
+		// A zero-valued state is the "invalid" state.
+		return SequenceState{}
+	}
+	if thisIsIncrementing {
+		newSequenceState.Increment = utils.Min(sequence.Increment, otherSequenceState.Increment)
+		newSequenceState.Start = utils.Min(sequence.Start, otherSequenceState.Start)
+	} else {
+		newSequenceState.Increment = utils.Max(sequence.Increment, otherSequenceState.Increment)
+		newSequenceState.Start = utils.Max(sequence.Start, otherSequenceState.Start)
+	}
+	if sequence.GreaterThan(otherSequenceState) {
+		newSequenceState.Current = sequence.Current
+	} else {
+		newSequenceState.Current = otherSequenceState.Current
+	}
+	newSequenceState.Minimum = utils.Min(sequence.Minimum, otherSequenceState.Minimum)
+	newSequenceState.Maximum = utils.Max(sequence.Maximum, otherSequenceState.Maximum)
+	newSequenceState.Cycle = sequence.Cycle || otherSequenceState.Cycle
+	newSequenceState.IsAtEnd = sequence.IsAtEnd && otherSequenceState.IsAtEnd
+	newSequenceState.HasBeenCalled = sequence.HasBeenCalled || otherSequenceState.HasBeenCalled
+	return newSequenceState
+}
+
+var _ sequences.SequenceState[SequenceState, int64] = SequenceState{}
+
+func (sequence SequenceState) CurrentValue() int64 {
+	return sequence.Current
+}
+
+func (sequence SequenceState) WithValue(v int64) SequenceState {
+	sequence.Current = v
+	sequence.IsAtEnd = false
+	return sequence
+}
+
+func (sequence SequenceState) WithSQLValue(ctx *sql.Context, v interface{}) (SequenceState, error) {
+	// TODO: Coercing happens here, based on the type of the sequence
+	return sequence.WithValue(v.(int64)), nil
+}
+
+func (sequence SequenceState) GreaterThan(other SequenceState) bool {
+	// A sequence that has wrapped around is further along than a sequence that hasn't.
+	// Otherwise, we see which sequence is further alone, in the direction that it's incrementing.
+	if sequence.Increment > 0 {
+		hasWrapped := sequence.Current < sequence.Start
+		otherHasWrapped := other.Current < sequence.Start
+		if hasWrapped == otherHasWrapped {
+			return sequence.Current > other.Current
+		} else {
+			// Exactly one of the sequences has wrapped around. That sequence is greater.
+			return hasWrapped
+		}
+	} else {
+		hasWrapped := sequence.Current > sequence.Start
+		otherHasWrapped := other.Current > sequence.Start
+		if hasWrapped == otherHasWrapped {
+			return sequence.Current < other.Current
+		} else {
+			// Exactly one of the sequences has wrapped around. That sequence is greater.
+			return hasWrapped
+		}
+	}
+}
+
+func (sequence SequenceState) AtEnd() bool {
+	return sequence.IsAtEnd
+}
+
+func (sequence SequenceState) Next() (sqlVal int64, hasNext bool, nextState SequenceState, err error) {
+	// First we'll check if we've reached the end, and cycle or error as necessary
+	sequence.HasBeenCalled = true
+	if sequence.IsAtEnd {
+		if !sequence.Cycle {
+			if sequence.Increment > 0 {
+				return 0, false, SequenceState{}, errors.Errorf(`nextval: reached maximum value of sequence "%s" (%d)`, sequence.Id, sequence.Maximum)
+			} else {
+				return 0, false, SequenceState{}, errors.Errorf(`nextval: reached minimum value of sequence "%s" (%d)`, sequence.Id, sequence.Minimum)
+			}
+		}
+		sequence.IsAtEnd = false
+		if sequence.Increment > 0 {
+			sequence.Current = sequence.Minimum
+		} else {
+			sequence.Current = sequence.Maximum
+		}
+	}
+	// We'll return the current value, so everything after this sets the value for the next call
+	valueToReturn := sequence.Current
+	// Increment the current value
+	if sequence.Increment > 0 {
+		// Check for overflow or crossing the maximum, meaning we're at the end
+		if sequence.Current > math.MaxInt64-sequence.Increment || sequence.Current+sequence.Increment > sequence.Maximum {
+			sequence.IsAtEnd = true
+		} else {
+			sequence.Current += sequence.Increment
+		}
+	} else {
+		// Check for underflow or crossing the minimum, meaning we're at the end
+		if sequence.Current < math.MinInt64-sequence.Increment || sequence.Current+sequence.Increment < sequence.Minimum {
+			sequence.IsAtEnd = true
+		} else {
+			sequence.Current += sequence.Increment
+		}
+	}
+	return valueToReturn, true, sequence, nil
+}
+
+// Sequence represents a single sequence within the pg_sequence table.
+type Sequence struct {
+	DataTypeID  id.Type
+	Persistence Persistence
+	SequenceState
+	OwnerTable  id.Table
+	OwnerColumn string
+}
+
+func (sequence *Sequence) GetSequenceState(ctx context.Context) (SequenceState, error) {
+	return sequence.SequenceState, nil
+}
+
+func (sequence *Sequence) HasSequenceState(ctx context.Context) (bool, error) {
+	return true, nil
+}
+
+func (sequence *Sequence) SetSequenceState(ctx context.Context, newSequenceState SequenceState) (*Sequence, error) {
+	newSequence := sequence
+	newSequence.SequenceState = newSequenceState
+	return newSequence, nil
+}
+
+func (sequence *Sequence) GetSequenceSqlType(ctx context.Context) (sql.Type, bool, error) {
+	switch sequence.DataTypeID.TypeName() {
+	case "int8":
+		return types.Int8, true, nil
+	case "int16":
+		return types.Int16, true, nil
+	case "int32":
+		return types.Int32, true, nil
+	case "int64":
+		return types.Int64, true, nil
+	}
+	return nil, false, fmt.Errorf("sequences: unknown sequence data type: %s", sequence.DataTypeID.TypeName())
+}
+
+func (sequence *Sequence) TrySetSequenceState(ctx *sql.Context, val SequenceState) (*Sequence, bool, error) {
+	newSequence, err := sequence.SetSequenceState(ctx, val)
+	return newSequence, true, err
 }
 
 var _ objinterface.Collection = (*Collection)(nil)
 var _ objinterface.RootObject = (*Sequence)(nil)
 var _ doltdb.RootObject = (*Sequence)(nil)
+var _ sequences.SequencedRelation[*Sequence, int64, SequenceState] = (*Sequence)(nil)
 
 // GetSequence returns the sequence with the given schema and name. Returns nil if the sequence cannot be found.
 func (pgs *Collection) GetSequence(ctx context.Context, name id.Sequence) (*Sequence, error) {
@@ -178,6 +341,34 @@ func (pgs *Collection) DropSequence(ctx context.Context, names ...id.Sequence) (
 		return err
 	}
 	pgs.underlyingMap = flushed
+
+	// When removing a sequence, we may need to remove it from the global state tracker.
+	// TODO: Pass in a sql.Context instead of casting here.
+	sqlContext := ctx.(*sql.Context)
+	sess := dsess.DSessFromSess(sqlContext.Session)
+	db, _, err := sess.Provider().SessionDatabase(sqlContext, sqlContext.GetCurrentDatabase())
+	sqleDb := db.(sqle.Database)
+	if err != nil {
+		return err
+	}
+	ws, err := sqleDb.GetWorkingSet(sqlContext)
+	if err != nil {
+		return err
+	}
+	for _, ddb := range db.DoltDatabases() {
+		for _, sequenceId := range names {
+			sequenceName := doltdb.TableName{Schema: sequenceId.SchemaName(), Name: sequenceId.SequenceName()}
+			err = sqle.RemoveRelationFromSequenceTracker(sqlContext,
+				sequenceName,
+				ddb,
+				ws.Ref(),
+				sqleDb.GetGlobalState(),
+				SequenceTrackerKey)
+			if err != nil {
+				return err
+			}
+		}
+	}
 	return nil
 }
 
@@ -278,19 +469,19 @@ func (pgs *Collection) NextVal(ctx context.Context, name id.Sequence) (int64, er
 		return 0, err
 	}
 	if seq == nil {
-		return 0, errors.Errorf(`relation "%s" does not exist`, name.SequenceName())
+		return 0, errors.Errorf(`sequence "%s" does not exist`, name.SequenceName())
 	}
 	return seq.nextValForSequence()
 }
 
 // SetVal sets the sequence to the
-func (pgs *Collection) SetVal(ctx context.Context, name id.Sequence, newValue int64, autoAdvance bool) error {
+func (pgs *Collection) SetVal(ctx context.Context, name id.Sequence, newValue int64, hasBeenCalled bool, autoAdvance bool) error {
 	seq, err := pgs.getSequence(ctx, name)
 	if err != nil {
 		return err
 	}
 	if seq == nil {
-		return errors.Errorf(`relation "%s" does not exist`, name.SequenceName())
+		return errors.Errorf(`sequence "%s" does not exist`, name.SequenceName())
 	}
 	if newValue < seq.Minimum || newValue > seq.Maximum {
 		return errors.Errorf(`setval: value %d is out of bounds for sequence "%s" (%d..%d)`,
@@ -298,7 +489,7 @@ func (pgs *Collection) SetVal(ctx context.Context, name id.Sequence, newValue in
 	}
 	seq.Current = newValue
 	seq.IsAtEnd = false
-	seq.HasBeenCalled = false
+	seq.HasBeenCalled = hasBeenCalled
 	if autoAdvance {
 		_, err := seq.nextValForSequence()
 		return err
@@ -435,40 +626,39 @@ func (pgs *Collection) writeCache(ctx context.Context) (err error) {
 
 // nextValForSequence increments the calling sequence.
 func (sequence *Sequence) nextValForSequence() (int64, error) {
-	// First we'll check if we've reached the end, and cycle or error as necessary
-	if sequence.IsAtEnd {
-		if !sequence.Cycle {
-			if sequence.Increment > 0 {
-				return 0, errors.Errorf(`nextval: reached maximum value of sequence "%s" (%d)`, sequence.Id, sequence.Maximum)
-			} else {
-				return 0, errors.Errorf(`nextval: reached minimum value of sequence "%s" (%d)`, sequence.Id, sequence.Minimum)
-			}
-		}
-		sequence.IsAtEnd = false
-		if sequence.Increment > 0 {
-			sequence.Current = sequence.Minimum
-		} else {
-			sequence.Current = sequence.Maximum
-		}
+	result, _, newSequence, err := sequence.Next()
+	if err != nil {
+		return 0, err
 	}
-	// We'll return the current value, so everything after this sets the value for the next call
-	sequence.HasBeenCalled = true
-	valueToReturn := sequence.Current
-	// Increment the current value
-	if sequence.Increment > 0 {
-		// Check for overflow or crossing the maximum, meaning we're at the end
-		if sequence.Current > math.MaxInt64-sequence.Increment || sequence.Current+sequence.Increment > sequence.Maximum {
-			sequence.IsAtEnd = true
-		} else {
-			sequence.Current += sequence.Increment
-		}
-	} else {
-		// Check for underflow or crossing the minimum, meaning we're at the end
-		if sequence.Current < math.MinInt64-sequence.Increment || sequence.Current+sequence.Increment < sequence.Minimum {
-			sequence.IsAtEnd = true
-		} else {
-			sequence.Current += sequence.Increment
-		}
+	sequence.SequenceState = newSequence
+	return result, nil
+}
+
+// SequenceSource reads relations from a RootValue by reading its RootObjects
+type SequenceSource struct{}
+
+var _ doltdb.RelationSource[*Sequence] = SequenceSource{}
+
+func (s SequenceSource) GetRelation(ctx context.Context, root doltdb.RootValue, tName doltdb.TableName) (relation *Sequence, resolvedName string, found bool, err error) {
+	obj, found, err := root.GetRootObject(ctx, tName)
+	if !found || err != nil {
+		return nil, "", found, err
+	}
+	if seq, ok := obj.(*Sequence); ok {
+		return seq, tName.Name, true, nil
+	}
+	return nil, "", found, nil
+}
+
+func (s SequenceSource) IterRelations(ctx context.Context, root doltdb.RootValue) iter.Seq2[doltdb.TableName, *Sequence] {
+	return func(yield func(doltdb.TableName, *Sequence) bool) {
+		_ = root.IterRootObjects(ctx, func(name doltdb.TableName, obj doltdb.RootObject) (stop bool, err error) {
+			if seq, ok := obj.(*Sequence); ok {
+				if !yield(name, seq) {
+					return true, nil
+				}
+			}
+			return false, nil
+		})
 	}
-	return valueToReturn, nil
 }
diff --git a/core/sequences/collection_test.go b/core/sequences/collection_test.go
index ec944d4b99..06791d8f7b 100644
--- a/core/sequences/collection_test.go
+++ b/core/sequences/collection_test.go
@@ -89,13 +89,15 @@ func newTestCollection(t *testing.T, ns tree.NodeStore) *Collection {
 // through Serialize and Deserialize. The exact values are not significant.
 func newTestSequence(schema, name string) *Sequence {
 	return &Sequence{
-		Id:        id.NewSequence(schema, name),
-		Start:     1,
-		Current:   1,
-		Increment: 1,
-		Minimum:   1,
-		Maximum:   math.MaxInt64,
-		Cache:     1,
+		SequenceState: SequenceState{
+			Id:        id.NewSequence(schema, name),
+			Start:     1,
+			Current:   1,
+			Increment: 1,
+			Minimum:   1,
+			Maximum:   math.MaxInt64,
+			Cache:     1,
+		},
 	}
 }
 
diff --git a/core/sequences/root_object.go b/core/sequences/root_object.go
index 35750e0327..46559eb853 100644
--- a/core/sequences/root_object.go
+++ b/core/sequences/root_object.go
@@ -325,6 +325,7 @@ func (pgs *Collection) RenameRootObject(ctx context.Context, oldName id.Id, newN
 	if !oldName.IsValid() || !newName.IsValid() || oldName.Section() != newName.Section() || oldName.Section() != id.Section_Sequence {
 		return errors.New("cannot rename sequence due to invalid name")
 	}
+	// TODO: Update ait
 	oldSeqName := id.Sequence(oldName)
 	newSeqName := id.Sequence(newName)
 	seq, err := pgs.GetSequence(ctx, oldSeqName)
diff --git a/go.mod b/go.mod
index 6f51bf51d9..0396aeeff1 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/PuerkitoBio/goquery v1.8.1
 	github.com/cockroachdb/apd/v3 v3.2.3
 	github.com/cockroachdb/errors v1.7.5
-	github.com/dolthub/dolt/go v0.40.5-0.20260804000445-86daffc60fe6
+	github.com/dolthub/dolt/go v0.40.5-0.20260805080557-82ca361b6b09
 	github.com/dolthub/eventsapi_schema v0.0.0-20260715220557-d9b4a1c6b4d4
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
 	github.com/dolthub/go-mysql-server v0.20.1-0.20260803224759-f6896710fd7d
diff --git a/go.sum b/go.sum
index 3eaabfec61..3c91c3da21 100644
--- a/go.sum
+++ b/go.sum
@@ -248,6 +248,12 @@ github.com/dolthub/dolt-mcp v0.3.4 h1:AyG5cw+fNWXDHXujtQnqUPZrpWtPg6FN6yYtjv1pP4
 github.com/dolthub/dolt-mcp v0.3.4/go.mod h1:bCZ7KHvDYs+M0e+ySgmGiNvLhcwsN7bbf5YCyillLrk=
 github.com/dolthub/dolt/go v0.40.5-0.20260804000445-86daffc60fe6 h1:avF4Wlos4AlJ1UbrCKfQrVAdLlP2ppLTcGSTvJkhYm8=
 github.com/dolthub/dolt/go v0.40.5-0.20260804000445-86daffc60fe6/go.mod h1:tu5+NUsslUw+3i+7b57DumjuAegSkbZSpFccQz0u0nk=
+github.com/dolthub/dolt/go v0.40.5-0.20260804155236-475bfe5f5ba4 h1:30ZdVM5S1gCWnNhcwpvZAJ8fcBM4Q3cKYl4CmdeYUOI=
+github.com/dolthub/dolt/go v0.40.5-0.20260804155236-475bfe5f5ba4/go.mod h1:azS/FhEQSpp0L9ARSwB6A98nqpRdKlvSYaEoQh2Grvw=
+github.com/dolthub/dolt/go v0.40.5-0.20260804160803-748773e6b7c6 h1:Um4xgEcROlfq0g25sMVdzBkXf1s/x6o8TUl85MRIUS8=
+github.com/dolthub/dolt/go v0.40.5-0.20260804160803-748773e6b7c6/go.mod h1:tu5+NUsslUw+3i+7b57DumjuAegSkbZSpFccQz0u0nk=
+github.com/dolthub/dolt/go v0.40.5-0.20260805080557-82ca361b6b09 h1:o02811SraoGmBmwaaQiNKIK5rfjpBGMfl9pEAsN4S2I=
+github.com/dolthub/dolt/go v0.40.5-0.20260805080557-82ca361b6b09/go.mod h1:tu5+NUsslUw+3i+7b57DumjuAegSkbZSpFccQz0u0nk=
 github.com/dolthub/eventsapi_schema v0.0.0-20260715220557-d9b4a1c6b4d4 h1:0mg9QEFdkkBwJMxvz1tCjHYmfG2iIC6aShj1InDq9/M=
 github.com/dolthub/eventsapi_schema v0.0.0-20260715220557-d9b4a1c6b4d4/go.mod h1:SSLraQS/jGLYFgff3vuZ+JbVUct6vyEeMzjLBqWqoyM=
 github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2 h1:u3PMzfF8RkKd3lB9pZ2bfn0qEG+1Gms9599cr0REMww=
diff --git a/server/analyzer/serial.go b/server/analyzer/serial.go
index a1f846e12c..10455d1708 100644
--- a/server/analyzer/serial.go
+++ b/server/analyzer/serial.go
@@ -138,17 +138,19 @@ func ReplaceSerial(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope
 		}
 
 		ctSequences = append(ctSequences, pgnodes.NewCreateSequence(false, "", false, &sequences.Sequence{
-			Id:          id.NewSequence("", sequenceName),
 			DataTypeID:  col.Type.(*pgtypes.DoltgresType).ID,
 			Persistence: sequences.Persistence_Permanent,
-			Start:       1,
-			Current:     1,
-			Increment:   1,
-			Minimum:     1,
-			Maximum:     maxValue,
-			Cache:       1,
-			Cycle:       false,
-			IsAtEnd:     false,
+			SequenceState: sequences.SequenceState{
+				Id:        id.NewSequence("", sequenceName),
+				Start:     1,
+				Current:   1,
+				Increment: 1,
+				Minimum:   1,
+				Maximum:   maxValue,
+				Cache:     1,
+				Cycle:     false,
+				IsAtEnd:   false,
+			},
 			OwnerTable:  id.NewTable("", createTable.Name()),
 			OwnerColumn: col.Name,
 		}))
@@ -187,7 +189,7 @@ func generateSequenceName(ctx *sql.Context, createTable *plan.CreateTable, col *
 // It parses schema and sequence names out of given expression.
 // There can be only one argument expression of string type.
 func authCheckSequenceFromExpr(ctx *sql.Context, ah sql.AuthorizationHandler, arg sql.Expression) error {
-	schemaName, seqName, err := functions.ParseRelationName(ctx, strings.Trim(arg.String(), "'"))
+	schemaName, seqName, err := functions.ParseRelationNameWithCurrentSchema(ctx, strings.Trim(arg.String(), "'"))
 	if err != nil {
 		return err
 	}
diff --git a/server/ast/create_sequence.go b/server/ast/create_sequence.go
index 21cf3b1617..c28f2fd4e4 100644
--- a/server/ast/create_sequence.go
+++ b/server/ast/create_sequence.go
@@ -186,17 +186,19 @@ func nodeCreateSequence(ctx *Context, node *tree.CreateSequence) (vitess.Stateme
 	// Returns the stored procedure call with all options
 	return vitess.InjectedStatement{
 		Statement: pgnodes.NewCreateSequence(node.IfNotExists, name.SchemaQualifier.String(), fromAlter, &sequences.Sequence{
-			Id:          id.NewSequence("", name.Name.String()),
 			DataTypeID:  dataType.ID,
 			Persistence: sequences.Persistence_Permanent,
-			Start:       start,
-			Current:     start,
-			Increment:   increment,
-			Minimum:     minValue,
-			Maximum:     maxValue,
-			Cache:       1,
-			Cycle:       cycle,
-			IsAtEnd:     false,
+			SequenceState: sequences.SequenceState{
+				Id:        id.NewSequence("", name.Name.String()),
+				Start:     start,
+				Current:   start,
+				Increment: increment,
+				Minimum:   minValue,
+				Maximum:   maxValue,
+				Cache:     1,
+				Cycle:     cycle,
+				IsAtEnd:   false,
+			},
 			OwnerTable:  id.NewTable("", ownerTableName),
 			OwnerColumn: ownerColumnName,
 		}),
diff --git a/server/functions/nextval.go b/server/functions/nextval.go
index 29431db338..b193588e33 100644
--- a/server/functions/nextval.go
+++ b/server/functions/nextval.go
@@ -15,11 +15,14 @@
 package functions
 
 import (
+	"github.com/cockroachdb/errors"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve"
 	"github.com/dolthub/go-mysql-server/sql"
 
-	"github.com/dolthub/doltgresql/core/id"
-
 	"github.com/dolthub/doltgresql/core"
+	"github.com/dolthub/doltgresql/core/id"
+	"github.com/dolthub/doltgresql/core/sequences"
 	"github.com/dolthub/doltgresql/server/functions/framework"
 	pgtypes "github.com/dolthub/doltgresql/server/types"
 )
@@ -30,6 +33,52 @@ func initNextVal() {
 	framework.RegisterFunction(nextval_regclass)
 }
 
+func nextval(ctx *sql.Context, ait *sequences.SequenceTracker, relationName string) (int64, error) {
+	// TODO: this needs a database name to support inserts into other databases (including inserts on other branches than the current one)
+	collection, err := core.GetSequencesCollectionFromContext(ctx, ctx.GetCurrentDatabase())
+	if err != nil {
+		return 0, err
+	}
+
+	db, err := getDb(ctx)
+	if err != nil {
+		return 0, err
+	}
+	root, err := db.GetRoot(ctx)
+	if err != nil {
+		return 0, err
+	}
+	var sequenceName doltdb.TableName
+	schema, relationBaseName, err := ParseRelationName(ctx, relationName)
+	if err != nil {
+		return 0, err
+	}
+	if schema != "" {
+		sequenceName = doltdb.TableName{Schema: schema, Name: relationBaseName}
+	} else {
+		var found bool
+		sequenceName, _, found, err = resolve.Relation(ctx, root, relationName, sequences.SequenceSource{})
+		if err != nil {
+			return 0, err
+		}
+		if !found {
+			return 0, errors.Errorf(`sequence "%s" does not exist`, relationName)
+		}
+	}
+	sequenceId := id.NewSequence(sequenceName.Schema, sequenceName.Name)
+
+	next, err := ait.Next(ctx, sequenceName, nil)
+	if err != nil {
+		return 0, err
+	}
+
+	err = collection.SetVal(ctx, sequenceId, next, true, true)
+	if err != nil {
+		return 0, err
+	}
+	return next, err
+}
+
 // nextval_text represents the PostgreSQL function of the same name, taking the same parameters.
 //
 // TODO: Even though we can implicitly convert a text param to a regclass param, it's an expensive process
@@ -43,17 +92,11 @@ var nextval_text = framework.Function1{
 	IsNonDeterministic: true,
 	Strict:             true,
 	Callable: func(ctx *sql.Context, _ [2]*pgtypes.DoltgresType, val any) (any, error) {
-		schema, sequence, err := ParseRelationName(ctx, val.(string))
+		ait, err := getSequenceTracker(ctx)
 		if err != nil {
-			return nil, err
-		}
-
-		// TODO: this needs a database name to support inserts into other databases (including inserts on other branches than the current one)
-		collection, err := core.GetSequencesCollectionFromContext(ctx, ctx.GetCurrentDatabase())
-		if err != nil {
-			return nil, err
+			return 0, err
 		}
-		return collection.NextVal(ctx, id.NewSequence(schema, sequence))
+		return nextval(ctx, ait, val.(string))
 	},
 }
 
@@ -69,17 +112,10 @@ var nextval_regclass = framework.Function1{
 		if err != nil {
 			return nil, err
 		}
-
-		schema, sequence, err := ParseRelationName(ctx, relationName)
+		ait, err := getSequenceTracker(ctx)
 		if err != nil {
-			return nil, err
-		}
-
-		// TODO: this needs a database name to support inserts into other databases (including inserts on other branches than the current one)
-		collection, err := core.GetSequencesCollectionFromContext(ctx, ctx.GetCurrentDatabase())
-		if err != nil {
-			return nil, err
+			return 0, err
 		}
-		return collection.NextVal(ctx, id.NewSequence(schema, sequence))
+		return nextval(ctx, ait, relationName)
 	},
 }
diff --git a/server/functions/pg_get_serial_sequence.go b/server/functions/pg_get_serial_sequence.go
index 7256135499..8292e39d47 100644
--- a/server/functions/pg_get_serial_sequence.go
+++ b/server/functions/pg_get_serial_sequence.go
@@ -49,10 +49,6 @@ var pg_get_serial_sequence_text_text = framework.Function2{
 		var err error
 		schemaName := ""
 		if strings.Contains(tableName, ".") {
-			// TODO: ParseRelationName() will return the first schema from the search_path if one is not included
-			//       in the relation name, but that doesn't mean it's the correct schema. It should be updated to
-			//       not return any schema name if one wasn't explicitly specified, then we should search for the
-			//       table on the search_path and find the first schema that contains a table with that name.
 			schemaName, tableName, err = ParseRelationName(ctx, tableName)
 			if err != nil {
 				return nil, err
@@ -71,7 +67,7 @@ var pg_get_serial_sequence_text_text = framework.Function2{
 				return nil, err
 			}
 			if !ok {
-				return nil, errors.Errorf(`relation "%s" does not exist`, tableName)
+				return nil, errors.Errorf(`sequence "%s" does not exist`, tableName)
 			}
 			schemaName = foundTableName.Schema
 		}
@@ -85,7 +81,7 @@ var pg_get_serial_sequence_text_text = framework.Function2{
 			return nil, err
 		}
 		if table == nil {
-			return nil, errors.Errorf(`relation "%s" does not exist`, tableName)
+			return nil, errors.Errorf(`sequence "%s" does not exist`, tableName)
 		}
 		tableSchema := table.Schema(ctx)
 
diff --git a/server/functions/setval.go b/server/functions/setval.go
index e37f327411..8d2b322e2b 100644
--- a/server/functions/setval.go
+++ b/server/functions/setval.go
@@ -15,13 +15,20 @@
 package functions
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/cockroachdb/errors"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/globalstate"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve"
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/doltgresql/core"
 	"github.com/dolthub/doltgresql/core/id"
+	"github.com/dolthub/doltgresql/core/sequences"
 	"github.com/dolthub/doltgresql/server/functions/framework"
 	pgtypes "github.com/dolthub/doltgresql/server/types"
 )
@@ -54,22 +61,89 @@ var setval_text_int64_boolean = framework.Function3{
 	Strict:             true,
 	Callable: func(ctx *sql.Context, _ [4]*pgtypes.DoltgresType, val1 any, val2 any, val3 any) (any, error) {
 		// TODO: this needs a database name to support inserts into other databases (including inserts on other branches than the current one)
+		relationName := val1.(string)
+		newVal := val2.(int64)
+		autoAdvance := val3.(bool)
 		collection, err := core.GetSequencesCollectionFromContext(ctx, ctx.GetCurrentDatabase())
 		if err != nil {
 			return nil, err
 		}
-		// TODO: this should take a regclass as the parameter to determine the schema
-		schema, relation, err := ParseRelationName(ctx, val1.(string))
+		db, err := getDb(ctx)
 		if err != nil {
 			return nil, err
 		}
-		return val2.(int64), collection.SetVal(ctx, id.NewSequence(schema, relation), val2.(int64), val3.(bool))
+		root, err := db.GetRoot(ctx)
+		if err != nil {
+			return nil, err
+		}
+		var sequenceName doltdb.TableName
+		var sequence *sequences.Sequence
+		var seqId id.Sequence
+		schema, relationBaseName, err := ParseRelationName(ctx, relationName)
+		if err != nil {
+			return nil, err
+		}
+		if schema != "" {
+			sequenceName = doltdb.TableName{Schema: schema, Name: relationBaseName}
+			seqId = id.NewSequence(sequenceName.Schema, sequenceName.Name)
+			sequence, err = collection.GetSequence(ctx, seqId)
+			if err != nil {
+				return nil, err
+			}
+			if sequence == nil {
+				return 0, errors.Errorf(`sequence "%s" does not exist`, relationName)
+			}
+		} else {
+			var found bool
+			sequenceName, sequence, found, err = resolve.Relation(ctx, root, relationName, sequences.SequenceSource{})
+			if err != nil {
+				return 0, err
+			}
+			if !found {
+				return 0, errors.Errorf(`sequence "%s" does not exist`, relationName)
+			}
+			seqId = id.NewSequence(sequenceName.Schema, sequenceName.Name)
+		}
+
+		sequenceTracker, err := dsess.GetSequenceTracker(ctx, db.GetGlobalState(), sequences.SequenceTrackerKey)
+		if err != nil {
+			return nil, err
+		}
+
+		ws, err := db.GetWorkingSet(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		nextState := sequence.SequenceState.WithValue(newVal)
+		if autoAdvance {
+			_, _, nextState, err = nextState.Next()
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// Set the global state for the sequence.
+		// This returns a new Sequence object, but we don't need it.
+		_, err = sequenceTracker.Set(ctx, sequenceName, sequence, ws.Ref(), nextState)
+
+		if err != nil {
+			return nil, err
+		}
+
+		// Set the state on the local version of the sequence too.
+		err = collection.SetVal(ctx, seqId, val2.(int64), false, val3.(bool))
+		if err != nil {
+			return nil, err
+		}
+		return newVal, nil
 	},
 }
 
-// ParseRelationName parses the schema and relation name from a relation name string, including trimming any
-// identifier quotes used in the name. For example, passing in 'public."MyTable"' would return 'public' and 'MyTable'.
-func ParseRelationName(ctx *sql.Context, name string) (schema string, relation string, err error) {
+// ParseRelationNameWithCurrentSchema parses the schema and relation name from a relation name string, including trimming any
+// identifier quotes used in the name. If the schema is not specified, the current schema is used.
+// For example, passing in 'public."MyTable"' would return 'public' and 'MyTable'.
+func ParseRelationNameWithCurrentSchema(ctx *sql.Context, name string) (schema string, relation string, err error) {
 	pathElems := strings.Split(name, ".")
 	switch len(pathElems) {
 	case 1:
@@ -95,3 +169,69 @@ func ParseRelationName(ctx *sql.Context, name string) (schema string, relation s
 
 	return schema, relation, nil
 }
+
+func ParseRelationBaseName(ctx *sql.Context, name string) (string, error) {
+	pathElems := strings.Split(name, ".")
+	var relation string
+	switch len(pathElems) {
+	case 1:
+		relation = pathElems[0]
+	case 2:
+		relation = pathElems[1]
+	case 3:
+		// database is not used atm
+		relation = pathElems[2]
+	default:
+		return "", errors.Errorf(`cannot parse relation: %s`, relation)
+	}
+	return strings.Trim(relation, `"`), nil
+}
+
+// ParseRelationName parses the schema and relation name from a relation name string, including trimming any
+// identifier quotes used in the name. If the schema is not specified, an empty string is returned.
+// For example, passing in 'public."MyTable"' would return 'public' and 'MyTable'.
+func ParseRelationName(ctx *sql.Context, name string) (schema string, relation string, err error) {
+	pathElems := strings.Split(name, ".")
+	switch len(pathElems) {
+	case 1:
+		schema = ""
+		relation = pathElems[0]
+	case 2:
+		schema = pathElems[0]
+		relation = pathElems[1]
+	case 3:
+		// database is not used atm
+		schema = pathElems[1]
+		relation = pathElems[2]
+	default:
+		return "", "", errors.Errorf(`cannot parse relation: %s`, name)
+	}
+
+	// Trim any quotes from the schema and the relation name
+	schema = strings.Trim(schema, `"`)
+	relation = strings.Trim(relation, `"`)
+
+	return schema, relation, nil
+}
+
+func getSequenceTracker(ctx *sql.Context) (*sequences.SequenceTracker, error) {
+	sess := dsess.DSessFromSess(ctx.Session)
+	db, err := sess.Provider().Database(ctx, sess.GetCurrentDatabase())
+	if err != nil {
+		return nil, err
+	}
+	globalStateProvider, ok := db.(globalstate.GlobalStateProvider)
+	if !ok {
+		return nil, fmt.Errorf("database %s does not implement globalstate.GlobalStateProvider", db.Name())
+	}
+	return dsess.GetSequenceTracker(ctx, globalStateProvider.GetGlobalState(), sequences.SequenceTrackerKey)
+}
+
+func getDb(ctx *sql.Context) (sqle.Database, error) {
+	sess := dsess.DSessFromSess(ctx.Session)
+	db, err := sess.Provider().Database(ctx, sess.GetCurrentDatabase())
+	if err != nil {
+		return sqle.Database{}, err
+	}
+	return db.(sqle.Database), nil
+}
diff --git a/server/node/create_sequence.go b/server/node/create_sequence.go
index e9aa6aa663..3493a9a500 100644
--- a/server/node/create_sequence.go
+++ b/server/node/create_sequence.go
@@ -23,6 +23,8 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/globalstate"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/plan"
 	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
@@ -190,6 +192,21 @@ func (c *CreateSequence) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, erro
 	if err = collection.CreateSequence(ctx, c.sequence); err != nil {
 		return nil, err
 	}
+	sess := dsess.DSessFromSess(ctx.Session)
+	db, err := sess.Provider().Database(ctx, sess.GetCurrentDatabase())
+	if err != nil {
+		return nil, err
+	}
+	sequenceTracker, err := dsess.GetSequenceTracker(ctx, db.(globalstate.GlobalStateProvider).GetGlobalState(), sequences.SequenceTrackerKey)
+	if err != nil {
+		return nil, err
+	}
+	seqState := c.sequence.SequenceState
+	seqName := doltdb.TableName{Name: c.sequence.Id.SequenceName(), Schema: c.sequence.Id.SchemaName()}
+	err = sequenceTracker.AddNewRelation(seqName, seqState)
+	if err != nil {
+		return nil, err
+	}
 	if c.fromAlter {
 		if tableColumn == nil {
 			// This check is to satisfy the linter
@@ -205,8 +222,7 @@ func (c *CreateSequence) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, erro
 		}
 		// TODO: Do we need to convert to a TableName and then call String? Are we reliant on the specific way it's formatted?
 		//  This is how it's done in the analyzer for SERIAL types, so assuming it's for a good reason.
-		seqName := doltdb.TableName{Name: c.sequence.Id.SequenceName(), Schema: c.sequence.Id.SchemaName()}.String()
-		nextVal, foundFunc, err := framework.GetFunction(ctx, "nextval", pgexprs.NewTextLiteral(seqName))
+		nextVal, foundFunc, err := framework.GetFunction(ctx, "nextval", pgexprs.NewTextLiteral(seqName.String()))
 		if err != nil {
 			return nil, err
 		}
diff --git a/server/pg_provider.go b/server/pg_provider.go
index 5ee68c91f5..f53df3c335 100644
--- a/server/pg_provider.go
+++ b/server/pg_provider.go
@@ -15,11 +15,15 @@
 package server
 
 import (
+	"context"
+
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 	"github.com/dolthub/go-mysql-server/sql"
 
+	"github.com/dolthub/doltgresql/core/sequences"
 	"github.com/dolthub/doltgresql/server/tables"
 )
 
@@ -31,6 +35,7 @@ type DoltgresDatabaseProvider struct {
 }
 
 var _ sql.DatabaseProvider = (*DoltgresDatabaseProvider)(nil)
+var _ dsess.DoltDatabaseProvider = (*DoltgresDatabaseProvider)(nil)
 
 // Database overrides DoltDatabaseProvider.Database to wrap the returned sql.Database
 // with PgDatabase, enabling relation-name uniqueness enforcement.
@@ -68,12 +73,34 @@ type DoltgresProviderFactory struct {
 
 var _ sqle.ProviderFactory = DoltgresProviderFactory{}
 
+func initSequenceTracker(ctx context.Context, db sqle.Database) error {
+	sequenceTracker, err := dsess.NewSequenceTracker(ctx, db.Name(), db.GetDoltDB(), sequences.SequenceSource{})
+	if err != nil {
+		return err
+	}
+	return db.GetGlobalState().AddSequenceTracker(ctx, sequences.SequenceTrackerKey, sequenceTracker)
+}
+
 // NewProvider overrides DoltProviderFactory.NewProvider to wrap the created provider in
 // DoltgresDatabaseProvider before returning it.
-func (f DoltgresProviderFactory) NewProvider(defaultBranch string, fs filesys.Filesys, databases []dsess.SqlDatabase, locations []filesys.Filesys, overrides sql.EngineOverrides) (sql.DatabaseProvider, error) {
-	inner, err := f.DoltProviderFactory.NewProvider(defaultBranch, fs, databases, locations, overrides)
+func (f DoltgresProviderFactory) NewProvider(ctx context.Context, defaultBranch string, fs filesys.Filesys, databases []dsess.SqlDatabase, locations []filesys.Filesys, overrides sql.EngineOverrides) (sql.DatabaseProvider, error) {
+	inner, err := f.DoltProviderFactory.NewProvider(ctx, defaultBranch, fs, databases, locations, overrides)
 	if err != nil {
 		return nil, err
 	}
-	return &DoltgresDatabaseProvider{inner.(*sqle.DoltDatabaseProvider)}, nil
+	innerDoltDatabaseProvider := inner.(*sqle.DoltDatabaseProvider)
+	doltgresProvider := &DoltgresDatabaseProvider{innerDoltDatabaseProvider}
+	for _, database := range innerDoltDatabaseProvider.DoltDatabases() {
+		if sqleDatabase, ok := database.(sqle.Database); ok {
+			err = initSequenceTracker(ctx, sqleDatabase)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	innerDoltDatabaseProvider.AddInitDatabaseHook(func(ctx *sql.Context, pro *sqle.DoltDatabaseProvider, name string, env *env.DoltEnv, db dsess.SqlDatabase) error {
+		sqleDatabase := db.(sqle.Database)
+		return initSequenceTracker(ctx, sqleDatabase)
+	})
+	return doltgresProvider, nil
 }
diff --git a/server/tables/database.go b/server/tables/database.go
index 29a09d47a3..eb5a85df5f 100644
--- a/server/tables/database.go
+++ b/server/tables/database.go
@@ -16,6 +16,7 @@ package tables
 
 import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/globalstate"
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/doltgresql/utils"
@@ -55,3 +56,7 @@ func (d Database) Name() string {
 func (d Database) SchemaName() string {
 	return d.db.SchemaName()
 }
+
+func (d Database) GetGlobalState() globalstate.GlobalState {
+	return d.db.GetGlobalState()
+}
diff --git a/testing/bats/remotes-file-system.bats b/testing/bats/remotes-file-system.bats
index f6c9b1372f..cb63825ee5 100644
--- a/testing/bats/remotes-file-system.bats
+++ b/testing/bats/remotes-file-system.bats
@@ -110,6 +110,10 @@ SQL
 
     # No further pull happens after this, so it's now safe to call nextval() directly: must
     # continue from 150 (next is 200), proving the synced state drives future values correctly too.
+    # Note: because of https://github.com/dolthub/dolt/issues/11387, we need to restart the server
+    # so that the global sequence tracker will detect the change
+    stop_sql_server
+    start_sql_server
     run query_server_for_db cloned -c "SELECT nextval('counter');"
     [ "$status" -eq 0 ]
     [[ "$output" =~ "200" ]] || false
diff --git a/testing/bats/root-objects.bats b/testing/bats/root-objects.bats
index e01c94d21d..c9fe05e9ec 100644
--- a/testing/bats/root-objects.bats
+++ b/testing/bats/root-objects.bats
@@ -40,7 +40,8 @@ SELECT dolt_checkout('other');
 SELECT nextval('test');
 SQL
     [ "$status" -eq 0 ]
-    [[ "$output" =~ "12" ]] || false
+    # Sequence values are globally synchronized, so switching branches shouldn't have any effect
+    [[ "$output" =~ "22" ]] || false
 }
 
 @test 'root-objects: start and stop' {
@@ -81,7 +82,8 @@ SELECT dolt_checkout('other');
 SELECT nextval('test');
 SQL
     [ "$status" -eq 0 ]
-    [[ "$output" =~ "12" ]] || false
+    # Sequence values are globally synchronized, so switching branches shouldn't have any effect
+    [[ "$output" =~ "22" ]] || false
 }
 
 @test 'root-objects: \d does not break' {
diff --git a/testing/go/dolt_functions_test.go b/testing/go/dolt_functions_test.go
index b099993861..fd94825680 100644
--- a/testing/go/dolt_functions_test.go
+++ b/testing/go/dolt_functions_test.go
@@ -1956,7 +1956,7 @@ func TestDoltPreviewMergeConflicts(t *testing.T) {
 				"INSERT INTO t_simple VALUES (2, 2);",
 				"INSERT INTO t_composite VALUES (2, 2, 2);",
 				"INSERT INTO t_array VALUES (ARRAY['def'], 2);",
-				"INSERT INTO t_serial VALUES (DEFAULT, 2);",
+				"INSERT INTO t_serial VALUES (2, 2);",
 				"INSERT INTO t_generated (pk, v1) VALUES (2, 2);",
 				"CREATE OR REPLACE FUNCTION f_trigger() RETURNS TRIGGER AS $$ BEGIN NEW.v1 := NEW.v1 * 33; RETURN NEW; END; $$ LANGUAGE plpgsql;",
 				"INSERT INTO t_trigger VALUES (2, 2);",
@@ -1967,7 +1967,7 @@ func TestDoltPreviewMergeConflicts(t *testing.T) {
 				"INSERT INTO t_simple VALUES (2, 3);",
 				"INSERT INTO t_composite VALUES (2, 2, 3);",
 				"INSERT INTO t_array VALUES (ARRAY['def'], 3);",
-				"INSERT INTO t_serial VALUES (DEFAULT, 3);",
+				"INSERT INTO t_serial VALUES (2, 3);",
 				"INSERT INTO t_generated (pk, v1) VALUES (2, 3);",
 				"CREATE OR REPLACE FUNCTION f_trigger() RETURNS TRIGGER AS $$ BEGIN NEW.v1 := NEW.v1 * 34; RETURN NEW; END; $$ LANGUAGE plpgsql;",
 				"INSERT INTO t_trigger VALUES (2, 3);",
diff --git a/testing/go/dolt_remote_test.go b/testing/go/dolt_remote_test.go
index a787f43832..c0f24bd6c8 100644
--- a/testing/go/dolt_remote_test.go
+++ b/testing/go/dolt_remote_test.go
@@ -235,9 +235,15 @@ func TestDoltRemote(t *testing.T) {
 				Query:    "select id, item from orders order by id;",
 				Expected: []sql.Row{{1, "widget"}},
 			},
+			{
+				Query:    "SELECT schemaname, sequencename, start_value, min_value, max_value, increment_by, cycle, cache_size, last_value FROM pg_sequences;",
+				Expected: []sql.Row{{"public", "counter", 1, 1, 9223372036854775807, 5, "f", 1, 1}},
+			},
 			{
 				Query:    "select nextval('counter');",
 				Expected: []sql.Row{{int64(6)}},
+				// TODO(https://github.com/dolthub/dolt/issues/11387): Update global state after pulling.
+				Skip: true,
 			},
 		},
 	})
diff --git a/testing/go/enginetest/concurrent_sequence_test.go b/testing/go/enginetest/concurrent_sequence_test.go
new file mode 100644
index 0000000000..483d533ff6
--- /dev/null
+++ b/testing/go/enginetest/concurrent_sequence_test.go
@@ -0,0 +1,149 @@
+// Copyright 2026 Dolthub, Inc.
+//
+// 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 enginetest
+
+import (
+	"context"
+	gosql "database/sql"
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/jackc/pgx/v5"
+
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConcurrentSequences(t *testing.T) {
+	const (
+		dbName       = "doltgres_concurrency_repro"
+		tableName    = "global_audit_log"
+		sequenceName = "myseq"
+		threadCount  = 100
+	)
+
+	ctx := context.Background()
+	sc, doltgresConfig := startServer(t, "", "")
+	require.NoError(t, sc.WaitForStart())
+	defer func() {
+		sc.Stop()
+		require.NoError(t, sc.WaitForStop())
+	}()
+
+	// openDB opens a connection pool to the named database. multiStatements is enabled so the
+	// batched setup below can be executed verbatim.
+	openDB := func(database string) *pgx.Conn {
+		dsn := fmt.Sprintf("postgres://%s:%s@localhost:%d", doltgresConfig.User(), doltgresConfig.Password(), doltgresConfig.Port())
+		//dsn := fmt.Sprintf("postgres://localhost:%d", doltgresConfig.Port())
+
+		// Connect to the server and create the default database with the given name.
+
+		//dsn := servercfg.ConnectionString(doltgresConfig, database)
+		//dsn = "postgres://" + dsn
+		if strings.Contains(dsn, "?") {
+			dsn += "&multiStatements=true"
+		} else {
+			dsn += "?multiStatements=true"
+		}
+		db, err := pgx.Connect(ctx, dsn)
+		//db, err := gosql.Open("postgres", dsn)
+		require.NoError(t, err)
+		return db
+	}
+
+	{
+		conn := openDB("dolt")
+		_, err := conn.Exec(ctx, fmt.Sprintf(`CREATE DATABASE IF NOT EXISTS "%s"`, dbName))
+		require.NoError(t, err)
+		require.NoError(t, conn.Close(ctx))
+	}
+
+	{
+		conn := openDB(dbName)
+		_, err := conn.Exec(ctx, fmt.Sprintf(`DROP TABLE IF EXISTS "%s"`, tableName))
+		require.NoError(t, err)
+		_, err = conn.Exec(ctx, fmt.Sprintf(
+			`CREATE SEQUENCE "%s" AS integer START WITH 1 INCREMENT BY 2 NO MINVALUE NO MAXVALUE CACHE 1;`, sequenceName))
+		require.NoError(t, err)
+		_, err = conn.Exec(ctx, fmt.Sprintf(
+			`CREATE TABLE "%s" (id INT NOT NULL PRIMARY KEY)`, tableName))
+		require.NoError(t, err)
+	}
+
+	var (
+		mu       sync.Mutex
+		failures []string
+		wg       sync.WaitGroup
+	)
+	for i := 1; i <= threadCount; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			conn := openDB(dbName)
+			defer conn.Close(ctx)
+			_, err := conn.Exec(ctx,
+				fmt.Sprintf(`INSERT INTO "%s" (id) SELECT nextval($1)`, tableName),
+				sequenceName)
+			if err != nil {
+				mu.Lock()
+				failures = append(failures, fmt.Sprintf("%T: %v", err, err))
+				mu.Unlock()
+			}
+			_, err = conn.Exec(ctx, `COMMIT`)
+			if err != nil {
+				mu.Lock()
+				failures = append(failures, fmt.Sprintf("%T: %v", err, err))
+				mu.Unlock()
+			}
+		}(i)
+	}
+	wg.Wait()
+
+	report := openDB(dbName)
+	defer report.Close(ctx)
+
+	var rowCount, distinctIds int
+	var maxID gosql.NullInt64
+	require.NoError(t, report.QueryRow(ctx, fmt.Sprintf(`SELECT COUNT(*) FROM "%s"`, tableName)).Scan(&rowCount))
+	require.NoError(t, report.QueryRow(ctx, fmt.Sprintf(`SELECT COUNT(DISTINCT id) FROM "%s"`, tableName)).Scan(&distinctIds))
+	require.NoError(t, report.QueryRow(ctx, fmt.Sprintf(`SELECT MAX(id) FROM "%s"`, tableName)).Scan(&maxID))
+
+	t.Logf("Attempted inserts : %d", threadCount)
+	t.Logf("Rows persisted    : %d", rowCount)
+	t.Logf("Distinct ids      : %d", distinctIds)
+	t.Logf("Max id            : %v", maxID.Int64)
+	t.Logf("Failed inserts    : %d", len(failures))
+
+	groups := map[string]int{}
+	for _, f := range failures {
+		groups[f]++
+	}
+	grouped := make([]string, 0, len(groups))
+	for msg := range groups {
+		grouped = append(grouped, msg)
+	}
+	sort.Slice(grouped, func(i, j int) bool { return groups[grouped[i]] > groups[grouped[j]] })
+	for _, msg := range grouped {
+		t.Logf("  %dx  %s", groups[msg], msg)
+	}
+
+	require.Emptyf(t, failures, "expected no failed inserts, got %d", len(failures))
+	require.Equalf(t, distinctIds, rowCount,
+		"duplicate auto-increment ids detected: %d rows but only %d distinct ids", rowCount, distinctIds)
+	require.Equalf(t, threadCount, rowCount, "expected %d rows persisted, got %d", threadCount, rowCount)
+}
diff --git a/testing/go/enginetest/doltgres_engine_test.go b/testing/go/enginetest/doltgres_engine_test.go
index f15f8f71ce..1ce824218f 100644
--- a/testing/go/enginetest/doltgres_engine_test.go
+++ b/testing/go/enginetest/doltgres_engine_test.go
@@ -973,6 +973,14 @@ func TestTransactions(t *testing.T) {
 	t.Skip()
 	h := newDoltgresServerHarness(t)
 	denginetest.RunTransactionTests(t, h, false)
+	RunDoltgresTransactionTests(t, h, false)
+}
+
+func TestTransactionsPrepared(t *testing.T) {
+	t.Skip()
+	h := newDoltgresServerHarness(t)
+	denginetest.RunTransactionTests(t, h, true)
+	RunDoltgresTransactionTests(t, h, true)
 }
 
 func TestBranchTransactions(t *testing.T) {
diff --git a/testing/go/enginetest/doltgres_harness_test.go b/testing/go/enginetest/doltgres_harness_test.go
index d036614007..1d901ba4c5 100644
--- a/testing/go/enginetest/doltgres_harness_test.go
+++ b/testing/go/enginetest/doltgres_harness_test.go
@@ -685,12 +685,6 @@ type DoltgresQueryEngine struct {
 
 var _ enginetest.QueryEngine = &DoltgresQueryEngine{}
 
-// Ptr is a helper function that returns a pointer to the value passed in. This is necessary to e.g. get a pointer to
-// a const value without assigning to an intermediate variable.
-func Ptr[T any](v T) *T {
-	return &v
-}
-
 const port = 5433
 
 func NewDoltgresQueryEngine(t *testing.T, harness *DoltgresHarness) *DoltgresQueryEngine {
diff --git a/testing/go/enginetest/doltgres_server_tests.go b/testing/go/enginetest/doltgres_server_tests.go
new file mode 100644
index 0000000000..0902bddc2f
--- /dev/null
+++ b/testing/go/enginetest/doltgres_server_tests.go
@@ -0,0 +1,41 @@
+package enginetest
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/dolthub/dolt/go/libraries/utils/svcs"
+	"github.com/stretchr/testify/require"
+
+	"github.com/dolthub/doltgresql/server"
+	"github.com/dolthub/doltgresql/servercfg"
+	"github.com/dolthub/doltgresql/servercfg/cfgdetails"
+)
+
+// Ptr is a helper function that returns a pointer to the value passed in. This is necessary to e.g. get a pointer to
+// a const value without assigning to an intermediate variable.
+func Ptr[T any](v T) *T {
+	return &v
+}
+
+// startServer will start sql-server with given host, unix socket file path and whether to use specific port, which is defined randomly.
+func startServer(t *testing.T, host string, unixSocketPath string) (*svcs.Controller, *servercfg.DoltgresConfig) {
+	rand.Seed(time.Now().UnixNano())
+	port := 15403 + rand.Intn(25)
+
+	doltgresConfig := servercfg.DoltgresConfig{
+		DoltgresConfig: cfgdetails.DoltgresConfig{
+			LogLevelStr: Ptr("debug"),
+			ListenerConfig: &cfgdetails.DoltgresListenerConfig{
+				//HostStr:    Ptr("localhost"),
+				PortNumber: &port,
+				//Socket:     Ptr(unixSocketPath),
+			},
+		},
+	}
+	ctrl, err := server.RunInMemory(&doltgresConfig, server.NewListener)
+	require.NoError(t, err)
+
+	return ctrl, &doltgresConfig
+}
diff --git a/testing/go/enginetest/doltgres_transaction_tests.go b/testing/go/enginetest/doltgres_transaction_tests.go
new file mode 100644
index 0000000000..49a2e59d5c
--- /dev/null
+++ b/testing/go/enginetest/doltgres_transaction_tests.go
@@ -0,0 +1,49 @@
+package enginetest
+
+import (
+	"testing"
+
+	denginetest "github.com/dolthub/dolt/go/libraries/doltcore/sqle/enginetest"
+	"github.com/dolthub/go-mysql-server/enginetest"
+	"github.com/dolthub/go-mysql-server/enginetest/queries"
+	"github.com/dolthub/go-mysql-server/sql"
+)
+
+func RunDoltgresTransactionTests(t *testing.T, h denginetest.DoltEnginetestHarness, prepared bool) {
+	for _, script := range SequenceTransactionTests {
+		func() {
+			h := h.NewHarness(t)
+			defer h.Close()
+			if prepared {
+				enginetest.TestTransactionScriptPrepared(t, h, script)
+			} else {
+				enginetest.TestTransactionScript(t, h, script)
+			}
+		}()
+	}
+}
+
+var SequenceTransactionTests = []queries.TransactionTest{
+	{
+		Name: "two auto increment values in two transactions",
+		SetUpScript: []string{
+			"CREATE SEQUENCE myseq AS integer START WITH 1 INCREMENT BY 2 NO MINVALUE NO MAXVALUE CACHE 1;",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query: "/* client a */ start transaction",
+			},
+			{
+				Query: "/* client b */ start transaction",
+			},
+			{
+				Query:    "/* client a */ select nextval('myseq')",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "/* client b */ select nextval('myseq')",
+				Expected: []sql.Row{{3}},
+			},
+		},
+	},
+}
diff --git a/testing/go/sequences_test.go b/testing/go/sequences_test.go
index dd8cb85c76..933269bd32 100644
--- a/testing/go/sequences_test.go
+++ b/testing/go/sequences_test.go
@@ -981,7 +981,7 @@ func TestSequences(t *testing.T) {
 			},
 		},
 		{
-			Name: "dolt_add, dolt_branch, dolt_checkout, dolt_commit, dolt_reset",
+			Name: "sequences are globally tracked across dolt_add, dolt_branch, dolt_checkout, dolt_commit, dolt_reset",
 			Assertions: []ScriptTestAssertion{
 				{
 					Query:    "CREATE SEQUENCE test;",
@@ -1035,7 +1035,7 @@ func TestSequences(t *testing.T) {
 				},
 				{
 					Query:    "SELECT nextval('test');",
-					Expected: []sql.Row{{12}},
+					Expected: []sql.Row{{22}},
 				},
 				{
 					Query:    "SELECT dolt_reset('--hard');",
@@ -1043,7 +1043,7 @@ func TestSequences(t *testing.T) {
 				},
 				{
 					Query:    "SELECT nextval('test');",
-					Expected: []sql.Row{{12}},
+					Expected: []sql.Row{{23}},
 				},
 			},
 		},
@@ -1099,6 +1099,7 @@ func TestSequences(t *testing.T) {
 		},
 		{
 			Name: "dolt_merge",
+			Skip: true,
 			Assertions: []ScriptTestAssertion{
 				{
 					Query:    "CREATE SEQUENCE test;",