diff --git a/tavern/internal/ent/client.go b/tavern/internal/ent/client.go
index c677b4fd5..88ef3dc98 100644
--- a/tavern/internal/ent/client.go
+++ b/tavern/internal/ent/client.go
@@ -1210,7 +1210,8 @@ func (c *TaskClient) QueryBeacon(t *Task) *BeaconQuery {
 
 // Hooks returns the client hooks.
 func (c *TaskClient) Hooks() []Hook {
-	return c.hooks.Task
+	hooks := c.hooks.Task
+	return append(hooks[:len(hooks):len(hooks)], task.Hooks[:]...)
 }
 
 // Interceptors returns the client interceptors.
diff --git a/tavern/internal/ent/gql_collection.go b/tavern/internal/ent/gql_collection.go
index 45c288914..6edfff931 100644
--- a/tavern/internal/ent/gql_collection.go
+++ b/tavern/internal/ent/gql_collection.go
@@ -719,6 +719,11 @@ func (t *TaskQuery) collectField(ctx context.Context, opCtx *graphql.OperationCo
 				selectedFields = append(selectedFields, task.FieldOutput)
 				fieldSeen[task.FieldOutput] = struct{}{}
 			}
+		case "outputSize":
+			if _, ok := fieldSeen[task.FieldOutputSize]; !ok {
+				selectedFields = append(selectedFields, task.FieldOutputSize)
+				fieldSeen[task.FieldOutputSize] = struct{}{}
+			}
 		case "error":
 			if _, ok := fieldSeen[task.FieldError]; !ok {
 				selectedFields = append(selectedFields, task.FieldError)
diff --git a/tavern/internal/ent/gql_pagination.go b/tavern/internal/ent/gql_pagination.go
index d544c7050..50196d99b 100644
--- a/tavern/internal/ent/gql_pagination.go
+++ b/tavern/internal/ent/gql_pagination.go
@@ -1990,6 +1990,20 @@ var (
 			}
 		},
 	}
+	// TaskOrderFieldOutputSize orders Task by output_size.
+	TaskOrderFieldOutputSize = &TaskOrderField{
+		Value: func(t *Task) (ent.Value, error) {
+			return t.OutputSize, nil
+		},
+		column: task.FieldOutputSize,
+		toTerm: task.ByOutputSize,
+		toCursor: func(t *Task) Cursor {
+			return Cursor{
+				ID:    t.ID,
+				Value: t.OutputSize,
+			}
+		},
+	}
 )
 
 // String implement fmt.Stringer interface.
@@ -2006,6 +2020,8 @@ func (f TaskOrderField) String() string {
 		str = "EXEC_STARTED_AT"
 	case TaskOrderFieldExecFinishedAt.column:
 		str = "EXEC_FINISHED_AT"
+	case TaskOrderFieldOutputSize.column:
+		str = "OUTPUT_SIZE"
 	}
 	return str
 }
@@ -2032,6 +2048,8 @@ func (f *TaskOrderField) UnmarshalGQL(v interface{}) error {
 		*f = *TaskOrderFieldExecStartedAt
 	case "EXEC_FINISHED_AT":
 		*f = *TaskOrderFieldExecFinishedAt
+	case "OUTPUT_SIZE":
+		*f = *TaskOrderFieldOutputSize
 	default:
 		return fmt.Errorf("%s is not a valid TaskOrderField", str)
 	}
diff --git a/tavern/internal/ent/gql_where_input.go b/tavern/internal/ent/gql_where_input.go
index 7dae62cbf..35f291807 100644
--- a/tavern/internal/ent/gql_where_input.go
+++ b/tavern/internal/ent/gql_where_input.go
@@ -1946,6 +1946,16 @@ type TaskWhereInput struct {
 	OutputEqualFold    *string  `json:"outputEqualFold,omitempty"`
 	OutputContainsFold *string  `json:"outputContainsFold,omitempty"`
 
+	// "output_size" field predicates.
+	OutputSize      *int  `json:"outputSize,omitempty"`
+	OutputSizeNEQ   *int  `json:"outputSizeNEQ,omitempty"`
+	OutputSizeIn    []int `json:"outputSizeIn,omitempty"`
+	OutputSizeNotIn []int `json:"outputSizeNotIn,omitempty"`
+	OutputSizeGT    *int  `json:"outputSizeGT,omitempty"`
+	OutputSizeGTE   *int  `json:"outputSizeGTE,omitempty"`
+	OutputSizeLT    *int  `json:"outputSizeLT,omitempty"`
+	OutputSizeLTE   *int  `json:"outputSizeLTE,omitempty"`
+
 	// "error" field predicates.
 	Error             *string  `json:"error,omitempty"`
 	ErrorNEQ          *string  `json:"errorNEQ,omitempty"`
@@ -2250,6 +2260,30 @@ func (i *TaskWhereInput) P() (predicate.Task, error) {
 	if i.OutputContainsFold != nil {
 		predicates = append(predicates, task.OutputContainsFold(*i.OutputContainsFold))
 	}
+	if i.OutputSize != nil {
+		predicates = append(predicates, task.OutputSizeEQ(*i.OutputSize))
+	}
+	if i.OutputSizeNEQ != nil {
+		predicates = append(predicates, task.OutputSizeNEQ(*i.OutputSizeNEQ))
+	}
+	if len(i.OutputSizeIn) > 0 {
+		predicates = append(predicates, task.OutputSizeIn(i.OutputSizeIn...))
+	}
+	if len(i.OutputSizeNotIn) > 0 {
+		predicates = append(predicates, task.OutputSizeNotIn(i.OutputSizeNotIn...))
+	}
+	if i.OutputSizeGT != nil {
+		predicates = append(predicates, task.OutputSizeGT(*i.OutputSizeGT))
+	}
+	if i.OutputSizeGTE != nil {
+		predicates = append(predicates, task.OutputSizeGTE(*i.OutputSizeGTE))
+	}
+	if i.OutputSizeLT != nil {
+		predicates = append(predicates, task.OutputSizeLT(*i.OutputSizeLT))
+	}
+	if i.OutputSizeLTE != nil {
+		predicates = append(predicates, task.OutputSizeLTE(*i.OutputSizeLTE))
+	}
 	if i.Error != nil {
 		predicates = append(predicates, task.ErrorEQ(*i.Error))
 	}
diff --git a/tavern/internal/ent/migrate/schema.go b/tavern/internal/ent/migrate/schema.go
index e25ce06f7..dbe7d4e38 100644
--- a/tavern/internal/ent/migrate/schema.go
+++ b/tavern/internal/ent/migrate/schema.go
@@ -131,6 +131,7 @@ var (
 		{Name: "exec_started_at", Type: field.TypeTime, Nullable: true},
 		{Name: "exec_finished_at", Type: field.TypeTime, Nullable: true},
 		{Name: "output", Type: field.TypeString, Nullable: true, Size: 2147483647},
+		{Name: "output_size", Type: field.TypeInt, Default: 0},
 		{Name: "error", Type: field.TypeString, Nullable: true},
 		{Name: "quest_tasks", Type: field.TypeInt},
 		{Name: "task_beacon", Type: field.TypeInt},
@@ -143,13 +144,13 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "tasks_quests_tasks",
-				Columns:    []*schema.Column{TasksColumns[8]},
+				Columns:    []*schema.Column{TasksColumns[9]},
 				RefColumns: []*schema.Column{QuestsColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "tasks_beacons_beacon",
-				Columns:    []*schema.Column{TasksColumns[9]},
+				Columns:    []*schema.Column{TasksColumns[10]},
 				RefColumns: []*schema.Column{BeaconsColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
diff --git a/tavern/internal/ent/mutation.go b/tavern/internal/ent/mutation.go
index 645c175f6..6ddbfa74e 100644
--- a/tavern/internal/ent/mutation.go
+++ b/tavern/internal/ent/mutation.go
@@ -3580,6 +3580,8 @@ type TaskMutation struct {
 	exec_started_at  *time.Time
 	exec_finished_at *time.Time
 	output           *string
+	output_size      *int
+	addoutput_size   *int
 	error            *string
 	clearedFields    map[string]struct{}
 	quest            *int
@@ -3957,6 +3959,62 @@ func (m *TaskMutation) ResetOutput() {
 	delete(m.clearedFields, task.FieldOutput)
 }
 
+// SetOutputSize sets the "output_size" field.
+func (m *TaskMutation) SetOutputSize(i int) {
+	m.output_size = &i
+	m.addoutput_size = nil
+}
+
+// OutputSize returns the value of the "output_size" field in the mutation.
+func (m *TaskMutation) OutputSize() (r int, exists bool) {
+	v := m.output_size
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldOutputSize returns the old "output_size" field's value of the Task entity.
+// If the Task object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *TaskMutation) OldOutputSize(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldOutputSize is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldOutputSize requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldOutputSize: %w", err)
+	}
+	return oldValue.OutputSize, nil
+}
+
+// AddOutputSize adds i to the "output_size" field.
+func (m *TaskMutation) AddOutputSize(i int) {
+	if m.addoutput_size != nil {
+		*m.addoutput_size += i
+	} else {
+		m.addoutput_size = &i
+	}
+}
+
+// AddedOutputSize returns the value that was added to the "output_size" field in this mutation.
+func (m *TaskMutation) AddedOutputSize() (r int, exists bool) {
+	v := m.addoutput_size
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ResetOutputSize resets all changes to the "output_size" field.
+func (m *TaskMutation) ResetOutputSize() {
+	m.output_size = nil
+	m.addoutput_size = nil
+}
+
 // SetError sets the "error" field.
 func (m *TaskMutation) SetError(s string) {
 	m.error = &s
@@ -4118,7 +4176,7 @@ func (m *TaskMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *TaskMutation) Fields() []string {
-	fields := make([]string, 0, 7)
+	fields := make([]string, 0, 8)
 	if m.created_at != nil {
 		fields = append(fields, task.FieldCreatedAt)
 	}
@@ -4137,6 +4195,9 @@ func (m *TaskMutation) Fields() []string {
 	if m.output != nil {
 		fields = append(fields, task.FieldOutput)
 	}
+	if m.output_size != nil {
+		fields = append(fields, task.FieldOutputSize)
+	}
 	if m.error != nil {
 		fields = append(fields, task.FieldError)
 	}
@@ -4160,6 +4221,8 @@ func (m *TaskMutation) Field(name string) (ent.Value, bool) {
 		return m.ExecFinishedAt()
 	case task.FieldOutput:
 		return m.Output()
+	case task.FieldOutputSize:
+		return m.OutputSize()
 	case task.FieldError:
 		return m.Error()
 	}
@@ -4183,6 +4246,8 @@ func (m *TaskMutation) OldField(ctx context.Context, name string) (ent.Value, er
 		return m.OldExecFinishedAt(ctx)
 	case task.FieldOutput:
 		return m.OldOutput(ctx)
+	case task.FieldOutputSize:
+		return m.OldOutputSize(ctx)
 	case task.FieldError:
 		return m.OldError(ctx)
 	}
@@ -4236,6 +4301,13 @@ func (m *TaskMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetOutput(v)
 		return nil
+	case task.FieldOutputSize:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetOutputSize(v)
+		return nil
 	case task.FieldError:
 		v, ok := value.(string)
 		if !ok {
@@ -4250,13 +4322,21 @@ func (m *TaskMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented/decremented during
 // this mutation.
 func (m *TaskMutation) AddedFields() []string {
-	return nil
+	var fields []string
+	if m.addoutput_size != nil {
+		fields = append(fields, task.FieldOutputSize)
+	}
+	return fields
 }
 
 // AddedField returns the numeric value that was incremented/decremented on a field
 // with the given name. The second boolean return value indicates that this field
 // was not set, or was not defined in the schema.
 func (m *TaskMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case task.FieldOutputSize:
+		return m.AddedOutputSize()
+	}
 	return nil, false
 }
 
@@ -4265,6 +4345,13 @@ func (m *TaskMutation) AddedField(name string) (ent.Value, bool) {
 // type.
 func (m *TaskMutation) AddField(name string, value ent.Value) error {
 	switch name {
+	case task.FieldOutputSize:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddOutputSize(v)
+		return nil
 	}
 	return fmt.Errorf("unknown Task numeric field %s", name)
 }
@@ -4343,6 +4430,9 @@ func (m *TaskMutation) ResetField(name string) error {
 	case task.FieldOutput:
 		m.ResetOutput()
 		return nil
+	case task.FieldOutputSize:
+		m.ResetOutputSize()
+		return nil
 	case task.FieldError:
 		m.ResetError()
 		return nil
diff --git a/tavern/internal/ent/runtime/runtime.go b/tavern/internal/ent/runtime/runtime.go
index 0ba78d73d..57804764e 100644
--- a/tavern/internal/ent/runtime/runtime.go
+++ b/tavern/internal/ent/runtime/runtime.go
@@ -109,6 +109,8 @@ func init() {
 	// tag.NameValidator is a validator for the "name" field. It is called by the builders before save.
 	tag.NameValidator = tagDescName.Validators[0].(func(string) error)
 	taskMixin := schema.Task{}.Mixin()
+	taskHooks := schema.Task{}.Hooks()
+	task.Hooks[0] = taskHooks[0]
 	taskMixinFields0 := taskMixin[0].Fields()
 	_ = taskMixinFields0
 	taskFields := schema.Task{}.Fields()
@@ -123,6 +125,12 @@ func init() {
 	task.DefaultLastModifiedAt = taskDescLastModifiedAt.Default.(func() time.Time)
 	// task.UpdateDefaultLastModifiedAt holds the default value on update for the last_modified_at field.
 	task.UpdateDefaultLastModifiedAt = taskDescLastModifiedAt.UpdateDefault.(func() time.Time)
+	// taskDescOutputSize is the schema descriptor for output_size field.
+	taskDescOutputSize := taskFields[4].Descriptor()
+	// task.DefaultOutputSize holds the default value on creation for the output_size field.
+	task.DefaultOutputSize = taskDescOutputSize.Default.(int)
+	// task.OutputSizeValidator is a validator for the "output_size" field. It is called by the builders before save.
+	task.OutputSizeValidator = taskDescOutputSize.Validators[0].(func(int) error)
 	tomeMixin := schema.Tome{}.Mixin()
 	tomeHooks := schema.Tome{}.Hooks()
 	tome.Hooks[0] = tomeHooks[0]
diff --git a/tavern/internal/ent/schema/task.go b/tavern/internal/ent/schema/task.go
index 5ff1c47c9..7dedb5f1a 100644
--- a/tavern/internal/ent/schema/task.go
+++ b/tavern/internal/ent/schema/task.go
@@ -1,11 +1,15 @@
 package schema
 
 import (
+	"context"
+	"fmt"
+
 	"entgo.io/contrib/entgql"
 	"entgo.io/ent"
 	"entgo.io/ent/schema"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
+	"realm.pub/tavern/internal/ent/hook"
 )
 
 // Task holds the schema definition for the Task entity.
@@ -37,6 +41,13 @@ func (Task) Fields() []ent.Field {
 		field.Text("output").
 			Optional().
 			Comment("Output from executing the task"),
+		field.Int("output_size").
+			Default(0).
+			Min(0).
+			Annotations(
+				entgql.OrderField("OUTPUT_SIZE"),
+			).
+			Comment("The size of the output in bytes"),
 		field.String("error").
 			Optional().
 			Comment("Error, if any, produced while executing the Task"),
@@ -70,3 +81,36 @@ func (Task) Mixin() []ent.Mixin {
 		MixinHistory{}, // created_at, last_modified_at
 	}
 }
+
+// Hooks defines middleware for mutations for the ent.
+func (Task) Hooks() []ent.Hook {
+	return []ent.Hook{
+		hook.On(HookDeriveTaskInfo(), ent.OpCreate|ent.OpUpdate|ent.OpUpdateOne),
+	}
+}
+
+// HookDeriveTaskInfo will update task info (e.g. output_size) whenever it is mutated.
+func HookDeriveTaskInfo() ent.Hook {
+	// Get the relevant methods from the Task Mutation
+	// See this example: https://github.com/ent/ent/blob/master/entc/integration/hooks/ent/schema/user.go#L98
+	type tMutation interface {
+		Output() (string, bool)
+		SetOutputSize(i int)
+	}
+
+	return func(next ent.Mutator) ent.Mutator {
+		return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+			// Get the mutation
+			t, ok := m.(tMutation)
+			if !ok {
+				return nil, fmt.Errorf("expected task mutation in schema hook, got: %+v", m)
+			}
+
+			// Set the new size
+			output, _ := t.Output()
+			t.SetOutputSize(len([]byte(output)))
+
+			return next.Mutate(ctx, m)
+		})
+	}
+}
diff --git a/tavern/internal/ent/task.go b/tavern/internal/ent/task.go
index cfa1d82a5..b00f701bb 100644
--- a/tavern/internal/ent/task.go
+++ b/tavern/internal/ent/task.go
@@ -31,6 +31,8 @@ type Task struct {
 	ExecFinishedAt time.Time `json:"exec_finished_at,omitempty"`
 	// Output from executing the task
 	Output string `json:"output,omitempty"`
+	// The size of the output in bytes
+	OutputSize int `json:"output_size,omitempty"`
 	// Error, if any, produced while executing the Task
 	Error string `json:"error,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -85,7 +87,7 @@ func (*Task) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case task.FieldID:
+		case task.FieldID, task.FieldOutputSize:
 			values[i] = new(sql.NullInt64)
 		case task.FieldOutput, task.FieldError:
 			values[i] = new(sql.NullString)
@@ -152,6 +154,12 @@ func (t *Task) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				t.Output = value.String
 			}
+		case task.FieldOutputSize:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field output_size", values[i])
+			} else if value.Valid {
+				t.OutputSize = int(value.Int64)
+			}
 		case task.FieldError:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field error", values[i])
@@ -236,6 +244,9 @@ func (t *Task) String() string {
 	builder.WriteString("output=")
 	builder.WriteString(t.Output)
 	builder.WriteString(", ")
+	builder.WriteString("output_size=")
+	builder.WriteString(fmt.Sprintf("%v", t.OutputSize))
+	builder.WriteString(", ")
 	builder.WriteString("error=")
 	builder.WriteString(t.Error)
 	builder.WriteByte(')')
diff --git a/tavern/internal/ent/task/task.go b/tavern/internal/ent/task/task.go
index 763b15da5..b03cf5e6c 100644
--- a/tavern/internal/ent/task/task.go
+++ b/tavern/internal/ent/task/task.go
@@ -5,6 +5,7 @@ package task
 import (
 	"time"
 
+	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 )
@@ -26,6 +27,8 @@ const (
 	FieldExecFinishedAt = "exec_finished_at"
 	// FieldOutput holds the string denoting the output field in the database.
 	FieldOutput = "output"
+	// FieldOutputSize holds the string denoting the output_size field in the database.
+	FieldOutputSize = "output_size"
 	// FieldError holds the string denoting the error field in the database.
 	FieldError = "error"
 	// EdgeQuest holds the string denoting the quest edge name in mutations.
@@ -59,6 +62,7 @@ var Columns = []string{
 	FieldExecStartedAt,
 	FieldExecFinishedAt,
 	FieldOutput,
+	FieldOutputSize,
 	FieldError,
 }
 
@@ -84,13 +88,23 @@ func ValidColumn(column string) bool {
 	return false
 }
 
+// Note that the variables below are initialized by the runtime
+// package on the initialization of the application. Therefore,
+// it should be imported in the main as follows:
+//
+//	import _ "realm.pub/tavern/internal/ent/runtime"
 var (
+	Hooks [1]ent.Hook
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
 	DefaultCreatedAt func() time.Time
 	// DefaultLastModifiedAt holds the default value on creation for the "last_modified_at" field.
 	DefaultLastModifiedAt func() time.Time
 	// UpdateDefaultLastModifiedAt holds the default value on update for the "last_modified_at" field.
 	UpdateDefaultLastModifiedAt func() time.Time
+	// DefaultOutputSize holds the default value on creation for the "output_size" field.
+	DefaultOutputSize int
+	// OutputSizeValidator is a validator for the "output_size" field. It is called by the builders before save.
+	OutputSizeValidator func(int) error
 )
 
 // OrderOption defines the ordering options for the Task queries.
@@ -131,6 +145,11 @@ func ByOutput(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldOutput, opts...).ToFunc()
 }
 
+// ByOutputSize orders the results by the output_size field.
+func ByOutputSize(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutputSize, opts...).ToFunc()
+}
+
 // ByError orders the results by the error field.
 func ByError(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldError, opts...).ToFunc()
diff --git a/tavern/internal/ent/task/where.go b/tavern/internal/ent/task/where.go
index 90f553b90..fa4aff0f3 100644
--- a/tavern/internal/ent/task/where.go
+++ b/tavern/internal/ent/task/where.go
@@ -85,6 +85,11 @@ func Output(v string) predicate.Task {
 	return predicate.Task(sql.FieldEQ(FieldOutput, v))
 }
 
+// OutputSize applies equality check predicate on the "output_size" field. It's identical to OutputSizeEQ.
+func OutputSize(v int) predicate.Task {
+	return predicate.Task(sql.FieldEQ(FieldOutputSize, v))
+}
+
 // Error applies equality check predicate on the "error" field. It's identical to ErrorEQ.
 func Error(v string) predicate.Task {
 	return predicate.Task(sql.FieldEQ(FieldError, v))
@@ -395,6 +400,46 @@ func OutputContainsFold(v string) predicate.Task {
 	return predicate.Task(sql.FieldContainsFold(FieldOutput, v))
 }
 
+// OutputSizeEQ applies the EQ predicate on the "output_size" field.
+func OutputSizeEQ(v int) predicate.Task {
+	return predicate.Task(sql.FieldEQ(FieldOutputSize, v))
+}
+
+// OutputSizeNEQ applies the NEQ predicate on the "output_size" field.
+func OutputSizeNEQ(v int) predicate.Task {
+	return predicate.Task(sql.FieldNEQ(FieldOutputSize, v))
+}
+
+// OutputSizeIn applies the In predicate on the "output_size" field.
+func OutputSizeIn(vs ...int) predicate.Task {
+	return predicate.Task(sql.FieldIn(FieldOutputSize, vs...))
+}
+
+// OutputSizeNotIn applies the NotIn predicate on the "output_size" field.
+func OutputSizeNotIn(vs ...int) predicate.Task {
+	return predicate.Task(sql.FieldNotIn(FieldOutputSize, vs...))
+}
+
+// OutputSizeGT applies the GT predicate on the "output_size" field.
+func OutputSizeGT(v int) predicate.Task {
+	return predicate.Task(sql.FieldGT(FieldOutputSize, v))
+}
+
+// OutputSizeGTE applies the GTE predicate on the "output_size" field.
+func OutputSizeGTE(v int) predicate.Task {
+	return predicate.Task(sql.FieldGTE(FieldOutputSize, v))
+}
+
+// OutputSizeLT applies the LT predicate on the "output_size" field.
+func OutputSizeLT(v int) predicate.Task {
+	return predicate.Task(sql.FieldLT(FieldOutputSize, v))
+}
+
+// OutputSizeLTE applies the LTE predicate on the "output_size" field.
+func OutputSizeLTE(v int) predicate.Task {
+	return predicate.Task(sql.FieldLTE(FieldOutputSize, v))
+}
+
 // ErrorEQ applies the EQ predicate on the "error" field.
 func ErrorEQ(v string) predicate.Task {
 	return predicate.Task(sql.FieldEQ(FieldError, v))
diff --git a/tavern/internal/ent/task_create.go b/tavern/internal/ent/task_create.go
index 4ded8f0a1..1b7c7d816 100644
--- a/tavern/internal/ent/task_create.go
+++ b/tavern/internal/ent/task_create.go
@@ -108,6 +108,20 @@ func (tc *TaskCreate) SetNillableOutput(s *string) *TaskCreate {
 	return tc
 }
 
+// SetOutputSize sets the "output_size" field.
+func (tc *TaskCreate) SetOutputSize(i int) *TaskCreate {
+	tc.mutation.SetOutputSize(i)
+	return tc
+}
+
+// SetNillableOutputSize sets the "output_size" field if the given value is not nil.
+func (tc *TaskCreate) SetNillableOutputSize(i *int) *TaskCreate {
+	if i != nil {
+		tc.SetOutputSize(*i)
+	}
+	return tc
+}
+
 // SetError sets the "error" field.
 func (tc *TaskCreate) SetError(s string) *TaskCreate {
 	tc.mutation.SetError(s)
@@ -151,7 +165,9 @@ func (tc *TaskCreate) Mutation() *TaskMutation {
 
 // Save creates the Task in the database.
 func (tc *TaskCreate) Save(ctx context.Context) (*Task, error) {
-	tc.defaults()
+	if err := tc.defaults(); err != nil {
+		return nil, err
+	}
 	return withHooks(ctx, tc.sqlSave, tc.mutation, tc.hooks)
 }
 
@@ -178,15 +194,26 @@ func (tc *TaskCreate) ExecX(ctx context.Context) {
 }
 
 // defaults sets the default values of the builder before save.
-func (tc *TaskCreate) defaults() {
+func (tc *TaskCreate) defaults() error {
 	if _, ok := tc.mutation.CreatedAt(); !ok {
+		if task.DefaultCreatedAt == nil {
+			return fmt.Errorf("ent: uninitialized task.DefaultCreatedAt (forgotten import ent/runtime?)")
+		}
 		v := task.DefaultCreatedAt()
 		tc.mutation.SetCreatedAt(v)
 	}
 	if _, ok := tc.mutation.LastModifiedAt(); !ok {
+		if task.DefaultLastModifiedAt == nil {
+			return fmt.Errorf("ent: uninitialized task.DefaultLastModifiedAt (forgotten import ent/runtime?)")
+		}
 		v := task.DefaultLastModifiedAt()
 		tc.mutation.SetLastModifiedAt(v)
 	}
+	if _, ok := tc.mutation.OutputSize(); !ok {
+		v := task.DefaultOutputSize
+		tc.mutation.SetOutputSize(v)
+	}
+	return nil
 }
 
 // check runs all checks and user-defined validators on the builder.
@@ -197,6 +224,14 @@ func (tc *TaskCreate) check() error {
 	if _, ok := tc.mutation.LastModifiedAt(); !ok {
 		return &ValidationError{Name: "last_modified_at", err: errors.New(`ent: missing required field "Task.last_modified_at"`)}
 	}
+	if _, ok := tc.mutation.OutputSize(); !ok {
+		return &ValidationError{Name: "output_size", err: errors.New(`ent: missing required field "Task.output_size"`)}
+	}
+	if v, ok := tc.mutation.OutputSize(); ok {
+		if err := task.OutputSizeValidator(v); err != nil {
+			return &ValidationError{Name: "output_size", err: fmt.Errorf(`ent: validator failed for field "Task.output_size": %w`, err)}
+		}
+	}
 	if _, ok := tc.mutation.QuestID(); !ok {
 		return &ValidationError{Name: "quest", err: errors.New(`ent: missing required edge "Task.quest"`)}
 	}
@@ -254,6 +289,10 @@ func (tc *TaskCreate) createSpec() (*Task, *sqlgraph.CreateSpec) {
 		_spec.SetField(task.FieldOutput, field.TypeString, value)
 		_node.Output = value
 	}
+	if value, ok := tc.mutation.OutputSize(); ok {
+		_spec.SetField(task.FieldOutputSize, field.TypeInt, value)
+		_node.OutputSize = value
+	}
 	if value, ok := tc.mutation.Error(); ok {
 		_spec.SetField(task.FieldError, field.TypeString, value)
 		_node.Error = value
@@ -428,6 +467,24 @@ func (u *TaskUpsert) ClearOutput() *TaskUpsert {
 	return u
 }
 
+// SetOutputSize sets the "output_size" field.
+func (u *TaskUpsert) SetOutputSize(v int) *TaskUpsert {
+	u.Set(task.FieldOutputSize, v)
+	return u
+}
+
+// UpdateOutputSize sets the "output_size" field to the value that was provided on create.
+func (u *TaskUpsert) UpdateOutputSize() *TaskUpsert {
+	u.SetExcluded(task.FieldOutputSize)
+	return u
+}
+
+// AddOutputSize adds v to the "output_size" field.
+func (u *TaskUpsert) AddOutputSize(v int) *TaskUpsert {
+	u.Add(task.FieldOutputSize, v)
+	return u
+}
+
 // SetError sets the "error" field.
 func (u *TaskUpsert) SetError(v string) *TaskUpsert {
 	u.Set(task.FieldError, v)
@@ -589,6 +646,27 @@ func (u *TaskUpsertOne) ClearOutput() *TaskUpsertOne {
 	})
 }
 
+// SetOutputSize sets the "output_size" field.
+func (u *TaskUpsertOne) SetOutputSize(v int) *TaskUpsertOne {
+	return u.Update(func(s *TaskUpsert) {
+		s.SetOutputSize(v)
+	})
+}
+
+// AddOutputSize adds v to the "output_size" field.
+func (u *TaskUpsertOne) AddOutputSize(v int) *TaskUpsertOne {
+	return u.Update(func(s *TaskUpsert) {
+		s.AddOutputSize(v)
+	})
+}
+
+// UpdateOutputSize sets the "output_size" field to the value that was provided on create.
+func (u *TaskUpsertOne) UpdateOutputSize() *TaskUpsertOne {
+	return u.Update(func(s *TaskUpsert) {
+		s.UpdateOutputSize()
+	})
+}
+
 // SetError sets the "error" field.
 func (u *TaskUpsertOne) SetError(v string) *TaskUpsertOne {
 	return u.Update(func(s *TaskUpsert) {
@@ -919,6 +997,27 @@ func (u *TaskUpsertBulk) ClearOutput() *TaskUpsertBulk {
 	})
 }
 
+// SetOutputSize sets the "output_size" field.
+func (u *TaskUpsertBulk) SetOutputSize(v int) *TaskUpsertBulk {
+	return u.Update(func(s *TaskUpsert) {
+		s.SetOutputSize(v)
+	})
+}
+
+// AddOutputSize adds v to the "output_size" field.
+func (u *TaskUpsertBulk) AddOutputSize(v int) *TaskUpsertBulk {
+	return u.Update(func(s *TaskUpsert) {
+		s.AddOutputSize(v)
+	})
+}
+
+// UpdateOutputSize sets the "output_size" field to the value that was provided on create.
+func (u *TaskUpsertBulk) UpdateOutputSize() *TaskUpsertBulk {
+	return u.Update(func(s *TaskUpsert) {
+		s.UpdateOutputSize()
+	})
+}
+
 // SetError sets the "error" field.
 func (u *TaskUpsertBulk) SetError(v string) *TaskUpsertBulk {
 	return u.Update(func(s *TaskUpsert) {
diff --git a/tavern/internal/ent/task_update.go b/tavern/internal/ent/task_update.go
index 1e14a052a..7e3bd5ac7 100644
--- a/tavern/internal/ent/task_update.go
+++ b/tavern/internal/ent/task_update.go
@@ -116,6 +116,27 @@ func (tu *TaskUpdate) ClearOutput() *TaskUpdate {
 	return tu
 }
 
+// SetOutputSize sets the "output_size" field.
+func (tu *TaskUpdate) SetOutputSize(i int) *TaskUpdate {
+	tu.mutation.ResetOutputSize()
+	tu.mutation.SetOutputSize(i)
+	return tu
+}
+
+// SetNillableOutputSize sets the "output_size" field if the given value is not nil.
+func (tu *TaskUpdate) SetNillableOutputSize(i *int) *TaskUpdate {
+	if i != nil {
+		tu.SetOutputSize(*i)
+	}
+	return tu
+}
+
+// AddOutputSize adds i to the "output_size" field.
+func (tu *TaskUpdate) AddOutputSize(i int) *TaskUpdate {
+	tu.mutation.AddOutputSize(i)
+	return tu
+}
+
 // SetError sets the "error" field.
 func (tu *TaskUpdate) SetError(s string) *TaskUpdate {
 	tu.mutation.SetError(s)
@@ -177,7 +198,9 @@ func (tu *TaskUpdate) ClearBeacon() *TaskUpdate {
 
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (tu *TaskUpdate) Save(ctx context.Context) (int, error) {
-	tu.defaults()
+	if err := tu.defaults(); err != nil {
+		return 0, err
+	}
 	return withHooks(ctx, tu.sqlSave, tu.mutation, tu.hooks)
 }
 
@@ -204,15 +227,24 @@ func (tu *TaskUpdate) ExecX(ctx context.Context) {
 }
 
 // defaults sets the default values of the builder before save.
-func (tu *TaskUpdate) defaults() {
+func (tu *TaskUpdate) defaults() error {
 	if _, ok := tu.mutation.LastModifiedAt(); !ok {
+		if task.UpdateDefaultLastModifiedAt == nil {
+			return fmt.Errorf("ent: uninitialized task.UpdateDefaultLastModifiedAt (forgotten import ent/runtime?)")
+		}
 		v := task.UpdateDefaultLastModifiedAt()
 		tu.mutation.SetLastModifiedAt(v)
 	}
+	return nil
 }
 
 // check runs all checks and user-defined validators on the builder.
 func (tu *TaskUpdate) check() error {
+	if v, ok := tu.mutation.OutputSize(); ok {
+		if err := task.OutputSizeValidator(v); err != nil {
+			return &ValidationError{Name: "output_size", err: fmt.Errorf(`ent: validator failed for field "Task.output_size": %w`, err)}
+		}
+	}
 	if _, ok := tu.mutation.QuestID(); tu.mutation.QuestCleared() && !ok {
 		return errors.New(`ent: clearing a required unique edge "Task.quest"`)
 	}
@@ -261,6 +293,12 @@ func (tu *TaskUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if tu.mutation.OutputCleared() {
 		_spec.ClearField(task.FieldOutput, field.TypeString)
 	}
+	if value, ok := tu.mutation.OutputSize(); ok {
+		_spec.SetField(task.FieldOutputSize, field.TypeInt, value)
+	}
+	if value, ok := tu.mutation.AddedOutputSize(); ok {
+		_spec.AddField(task.FieldOutputSize, field.TypeInt, value)
+	}
 	if value, ok := tu.mutation.Error(); ok {
 		_spec.SetField(task.FieldError, field.TypeString, value)
 	}
@@ -431,6 +469,27 @@ func (tuo *TaskUpdateOne) ClearOutput() *TaskUpdateOne {
 	return tuo
 }
 
+// SetOutputSize sets the "output_size" field.
+func (tuo *TaskUpdateOne) SetOutputSize(i int) *TaskUpdateOne {
+	tuo.mutation.ResetOutputSize()
+	tuo.mutation.SetOutputSize(i)
+	return tuo
+}
+
+// SetNillableOutputSize sets the "output_size" field if the given value is not nil.
+func (tuo *TaskUpdateOne) SetNillableOutputSize(i *int) *TaskUpdateOne {
+	if i != nil {
+		tuo.SetOutputSize(*i)
+	}
+	return tuo
+}
+
+// AddOutputSize adds i to the "output_size" field.
+func (tuo *TaskUpdateOne) AddOutputSize(i int) *TaskUpdateOne {
+	tuo.mutation.AddOutputSize(i)
+	return tuo
+}
+
 // SetError sets the "error" field.
 func (tuo *TaskUpdateOne) SetError(s string) *TaskUpdateOne {
 	tuo.mutation.SetError(s)
@@ -505,7 +564,9 @@ func (tuo *TaskUpdateOne) Select(field string, fields ...string) *TaskUpdateOne
 
 // Save executes the query and returns the updated Task entity.
 func (tuo *TaskUpdateOne) Save(ctx context.Context) (*Task, error) {
-	tuo.defaults()
+	if err := tuo.defaults(); err != nil {
+		return nil, err
+	}
 	return withHooks(ctx, tuo.sqlSave, tuo.mutation, tuo.hooks)
 }
 
@@ -532,15 +593,24 @@ func (tuo *TaskUpdateOne) ExecX(ctx context.Context) {
 }
 
 // defaults sets the default values of the builder before save.
-func (tuo *TaskUpdateOne) defaults() {
+func (tuo *TaskUpdateOne) defaults() error {
 	if _, ok := tuo.mutation.LastModifiedAt(); !ok {
+		if task.UpdateDefaultLastModifiedAt == nil {
+			return fmt.Errorf("ent: uninitialized task.UpdateDefaultLastModifiedAt (forgotten import ent/runtime?)")
+		}
 		v := task.UpdateDefaultLastModifiedAt()
 		tuo.mutation.SetLastModifiedAt(v)
 	}
+	return nil
 }
 
 // check runs all checks and user-defined validators on the builder.
 func (tuo *TaskUpdateOne) check() error {
+	if v, ok := tuo.mutation.OutputSize(); ok {
+		if err := task.OutputSizeValidator(v); err != nil {
+			return &ValidationError{Name: "output_size", err: fmt.Errorf(`ent: validator failed for field "Task.output_size": %w`, err)}
+		}
+	}
 	if _, ok := tuo.mutation.QuestID(); tuo.mutation.QuestCleared() && !ok {
 		return errors.New(`ent: clearing a required unique edge "Task.quest"`)
 	}
@@ -606,6 +676,12 @@ func (tuo *TaskUpdateOne) sqlSave(ctx context.Context) (_node *Task, err error)
 	if tuo.mutation.OutputCleared() {
 		_spec.ClearField(task.FieldOutput, field.TypeString)
 	}
+	if value, ok := tuo.mutation.OutputSize(); ok {
+		_spec.SetField(task.FieldOutputSize, field.TypeInt, value)
+	}
+	if value, ok := tuo.mutation.AddedOutputSize(); ok {
+		_spec.AddField(task.FieldOutputSize, field.TypeInt, value)
+	}
 	if value, ok := tuo.mutation.Error(); ok {
 		_spec.SetField(task.FieldError, field.TypeString, value)
 	}
diff --git a/tavern/internal/graphql/generated/ent.generated.go b/tavern/internal/graphql/generated/ent.generated.go
index 880f477a7..5e86aa4bf 100644
--- a/tavern/internal/graphql/generated/ent.generated.go
+++ b/tavern/internal/graphql/generated/ent.generated.go
@@ -666,6 +666,8 @@ func (ec *executionContext) fieldContext_Beacon_tasks(ctx context.Context, field
 				return ec.fieldContext_Task_execFinishedAt(ctx, field)
 			case "output":
 				return ec.fieldContext_Task_output(ctx, field)
+			case "outputSize":
+				return ec.fieldContext_Task_outputSize(ctx, field)
 			case "error":
 				return ec.fieldContext_Task_error(ctx, field)
 			case "quest":
@@ -2908,6 +2910,8 @@ func (ec *executionContext) fieldContext_Quest_tasks(ctx context.Context, field
 				return ec.fieldContext_Task_execFinishedAt(ctx, field)
 			case "output":
 				return ec.fieldContext_Task_output(ctx, field)
+			case "outputSize":
+				return ec.fieldContext_Task_outputSize(ctx, field)
 			case "error":
 				return ec.fieldContext_Task_error(ctx, field)
 			case "quest":
@@ -3461,6 +3465,50 @@ func (ec *executionContext) fieldContext_Task_output(ctx context.Context, field
 	return fc, nil
 }
 
+func (ec *executionContext) _Task_outputSize(ctx context.Context, field graphql.CollectedField, obj *ent.Task) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Task_outputSize(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.OutputSize, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(int)
+	fc.Result = res
+	return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_Task_outputSize(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "Task",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Int does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
 func (ec *executionContext) _Task_error(ctx context.Context, field graphql.CollectedField, obj *ent.Task) (ret graphql.Marshaler) {
 	fc, err := ec.fieldContext_Task_error(ctx, field)
 	if err != nil {
@@ -3825,6 +3873,8 @@ func (ec *executionContext) fieldContext_TaskEdge_node(ctx context.Context, fiel
 				return ec.fieldContext_Task_execFinishedAt(ctx, field)
 			case "output":
 				return ec.fieldContext_Task_output(ctx, field)
+			case "outputSize":
+				return ec.fieldContext_Task_outputSize(ctx, field)
 			case "error":
 				return ec.fieldContext_Task_error(ctx, field)
 			case "quest":
@@ -7837,7 +7887,7 @@ func (ec *executionContext) unmarshalInputTaskWhereInput(ctx context.Context, ob
 		asMap[k] = v
 	}
 
-	fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "lastModifiedAt", "lastModifiedAtNEQ", "lastModifiedAtIn", "lastModifiedAtNotIn", "lastModifiedAtGT", "lastModifiedAtGTE", "lastModifiedAtLT", "lastModifiedAtLTE", "claimedAt", "claimedAtNEQ", "claimedAtIn", "claimedAtNotIn", "claimedAtGT", "claimedAtGTE", "claimedAtLT", "claimedAtLTE", "claimedAtIsNil", "claimedAtNotNil", "execStartedAt", "execStartedAtNEQ", "execStartedAtIn", "execStartedAtNotIn", "execStartedAtGT", "execStartedAtGTE", "execStartedAtLT", "execStartedAtLTE", "execStartedAtIsNil", "execStartedAtNotNil", "execFinishedAt", "execFinishedAtNEQ", "execFinishedAtIn", "execFinishedAtNotIn", "execFinishedAtGT", "execFinishedAtGTE", "execFinishedAtLT", "execFinishedAtLTE", "execFinishedAtIsNil", "execFinishedAtNotNil", "output", "outputNEQ", "outputIn", "outputNotIn", "outputGT", "outputGTE", "outputLT", "outputLTE", "outputContains", "outputHasPrefix", "outputHasSuffix", "outputIsNil", "outputNotNil", "outputEqualFold", "outputContainsFold", "error", "errorNEQ", "errorIn", "errorNotIn", "errorGT", "errorGTE", "errorLT", "errorLTE", "errorContains", "errorHasPrefix", "errorHasSuffix", "errorIsNil", "errorNotNil", "errorEqualFold", "errorContainsFold", "hasQuest", "hasQuestWith", "hasBeacon", "hasBeaconWith"}
+	fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "lastModifiedAt", "lastModifiedAtNEQ", "lastModifiedAtIn", "lastModifiedAtNotIn", "lastModifiedAtGT", "lastModifiedAtGTE", "lastModifiedAtLT", "lastModifiedAtLTE", "claimedAt", "claimedAtNEQ", "claimedAtIn", "claimedAtNotIn", "claimedAtGT", "claimedAtGTE", "claimedAtLT", "claimedAtLTE", "claimedAtIsNil", "claimedAtNotNil", "execStartedAt", "execStartedAtNEQ", "execStartedAtIn", "execStartedAtNotIn", "execStartedAtGT", "execStartedAtGTE", "execStartedAtLT", "execStartedAtLTE", "execStartedAtIsNil", "execStartedAtNotNil", "execFinishedAt", "execFinishedAtNEQ", "execFinishedAtIn", "execFinishedAtNotIn", "execFinishedAtGT", "execFinishedAtGTE", "execFinishedAtLT", "execFinishedAtLTE", "execFinishedAtIsNil", "execFinishedAtNotNil", "output", "outputNEQ", "outputIn", "outputNotIn", "outputGT", "outputGTE", "outputLT", "outputLTE", "outputContains", "outputHasPrefix", "outputHasSuffix", "outputIsNil", "outputNotNil", "outputEqualFold", "outputContainsFold", "outputSize", "outputSizeNEQ", "outputSizeIn", "outputSizeNotIn", "outputSizeGT", "outputSizeGTE", "outputSizeLT", "outputSizeLTE", "error", "errorNEQ", "errorIn", "errorNotIn", "errorGT", "errorGTE", "errorLT", "errorLTE", "errorContains", "errorHasPrefix", "errorHasSuffix", "errorIsNil", "errorNotNil", "errorEqualFold", "errorContainsFold", "hasQuest", "hasQuestWith", "hasBeacon", "hasBeaconWith"}
 	for _, k := range fieldsInOrder {
 		v, ok := asMap[k]
 		if !ok {
@@ -8492,6 +8542,78 @@ func (ec *executionContext) unmarshalInputTaskWhereInput(ctx context.Context, ob
 				return it, err
 			}
 			it.OutputContainsFold = data
+		case "outputSize":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSize"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSize = data
+		case "outputSizeNEQ":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeNEQ"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeNEQ = data
+		case "outputSizeIn":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeIn"))
+			data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeIn = data
+		case "outputSizeNotIn":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeNotIn"))
+			data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeNotIn = data
+		case "outputSizeGT":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeGT"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeGT = data
+		case "outputSizeGTE":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeGTE"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeGTE = data
+		case "outputSizeLT":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeLT"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeLT = data
+		case "outputSizeLTE":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("outputSizeLTE"))
+			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+			if err != nil {
+				return it, err
+			}
+			it.OutputSizeLTE = data
 		case "error":
 			var err error
 
@@ -11121,6 +11243,11 @@ func (ec *executionContext) _Task(ctx context.Context, sel ast.SelectionSet, obj
 			out.Values[i] = ec._Task_execFinishedAt(ctx, field, obj)
 		case "output":
 			out.Values[i] = ec._Task_output(ctx, field, obj)
+		case "outputSize":
+			out.Values[i] = ec._Task_outputSize(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&out.Invalids, 1)
+			}
 		case "error":
 			out.Values[i] = ec._Task_error(ctx, field, obj)
 		case "quest":
diff --git a/tavern/internal/graphql/generated/mutation.generated.go b/tavern/internal/graphql/generated/mutation.generated.go
index d16d2934e..ee55d23b0 100644
--- a/tavern/internal/graphql/generated/mutation.generated.go
+++ b/tavern/internal/graphql/generated/mutation.generated.go
@@ -744,6 +744,8 @@ func (ec *executionContext) fieldContext_Mutation_claimTasks(ctx context.Context
 				return ec.fieldContext_Task_execFinishedAt(ctx, field)
 			case "output":
 				return ec.fieldContext_Task_output(ctx, field)
+			case "outputSize":
+				return ec.fieldContext_Task_outputSize(ctx, field)
 			case "error":
 				return ec.fieldContext_Task_error(ctx, field)
 			case "quest":
@@ -818,6 +820,8 @@ func (ec *executionContext) fieldContext_Mutation_submitTaskResult(ctx context.C
 				return ec.fieldContext_Task_execFinishedAt(ctx, field)
 			case "output":
 				return ec.fieldContext_Task_output(ctx, field)
+			case "outputSize":
+				return ec.fieldContext_Task_outputSize(ctx, field)
 			case "error":
 				return ec.fieldContext_Task_error(ctx, field)
 			case "quest":
diff --git a/tavern/internal/graphql/generated/root_.generated.go b/tavern/internal/graphql/generated/root_.generated.go
index 81432efc8..534c2918b 100644
--- a/tavern/internal/graphql/generated/root_.generated.go
+++ b/tavern/internal/graphql/generated/root_.generated.go
@@ -138,6 +138,7 @@ type ComplexityRoot struct {
 		ID             func(childComplexity int) int
 		LastModifiedAt func(childComplexity int) int
 		Output         func(childComplexity int) int
+		OutputSize     func(childComplexity int) int
 		Quest          func(childComplexity int) int
 	}
 
@@ -769,6 +770,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Task.Output(childComplexity), true
 
+	case "Task.outputSize":
+		if e.complexity.Task.OutputSize == nil {
+			break
+		}
+
+		return e.complexity.Task.OutputSize(childComplexity), true
+
 	case "Task.quest":
 		if e.complexity.Task.Quest == nil {
 			break
@@ -1669,6 +1677,8 @@ type Task implements Node {
   execFinishedAt: Time
   """Output from executing the task"""
   output: String
+  """The size of the output in bytes"""
+  outputSize: Int!
   """Error, if any, produced while executing the Task"""
   error: String
   quest: Quest!
@@ -1704,6 +1714,7 @@ enum TaskOrderField {
   CLAIMED_AT
   EXEC_STARTED_AT
   EXEC_FINISHED_AT
+  OUTPUT_SIZE
 }
 """
 TaskWhereInput is used for filtering Task objects.
@@ -1789,6 +1800,15 @@ input TaskWhereInput {
   outputNotNil: Boolean
   outputEqualFold: String
   outputContainsFold: String
+  """output_size field predicates"""
+  outputSize: Int
+  outputSizeNEQ: Int
+  outputSizeIn: [Int!]
+  outputSizeNotIn: [Int!]
+  outputSizeGT: Int
+  outputSizeGTE: Int
+  outputSizeLT: Int
+  outputSizeLTE: Int
   """error field predicates"""
   error: String
   errorNEQ: String
diff --git a/tavern/internal/graphql/schema.graphql b/tavern/internal/graphql/schema.graphql
index 4734fa18c..654f0b661 100644
--- a/tavern/internal/graphql/schema.graphql
+++ b/tavern/internal/graphql/schema.graphql
@@ -635,6 +635,8 @@ type Task implements Node {
   execFinishedAt: Time
   """Output from executing the task"""
   output: String
+  """The size of the output in bytes"""
+  outputSize: Int!
   """Error, if any, produced while executing the Task"""
   error: String
   quest: Quest!
@@ -670,6 +672,7 @@ enum TaskOrderField {
   CLAIMED_AT
   EXEC_STARTED_AT
   EXEC_FINISHED_AT
+  OUTPUT_SIZE
 }
 """
 TaskWhereInput is used for filtering Task objects.
@@ -755,6 +758,15 @@ input TaskWhereInput {
   outputNotNil: Boolean
   outputEqualFold: String
   outputContainsFold: String
+  """output_size field predicates"""
+  outputSize: Int
+  outputSizeNEQ: Int
+  outputSizeIn: [Int!]
+  outputSizeNotIn: [Int!]
+  outputSizeGT: Int
+  outputSizeGTE: Int
+  outputSizeLT: Int
+  outputSizeLTE: Int
   """error field predicates"""
   error: String
   errorNEQ: String
diff --git a/tavern/internal/graphql/schema/ent.graphql b/tavern/internal/graphql/schema/ent.graphql
index d0302ba60..f049210fb 100644
--- a/tavern/internal/graphql/schema/ent.graphql
+++ b/tavern/internal/graphql/schema/ent.graphql
@@ -630,6 +630,8 @@ type Task implements Node {
   execFinishedAt: Time
   """Output from executing the task"""
   output: String
+  """The size of the output in bytes"""
+  outputSize: Int!
   """Error, if any, produced while executing the Task"""
   error: String
   quest: Quest!
@@ -665,6 +667,7 @@ enum TaskOrderField {
   CLAIMED_AT
   EXEC_STARTED_AT
   EXEC_FINISHED_AT
+  OUTPUT_SIZE
 }
 """
 TaskWhereInput is used for filtering Task objects.
@@ -750,6 +753,15 @@ input TaskWhereInput {
   outputNotNil: Boolean
   outputEqualFold: String
   outputContainsFold: String
+  """output_size field predicates"""
+  outputSize: Int
+  outputSizeNEQ: Int
+  outputSizeIn: [Int!]
+  outputSizeNotIn: [Int!]
+  outputSizeGT: Int
+  outputSizeGTE: Int
+  outputSizeLT: Int
+  outputSizeLTE: Int
   """error field predicates"""
   error: String
   errorNEQ: String
diff --git a/tavern/internal/www/schema.graphql b/tavern/internal/www/schema.graphql
index 4734fa18c..654f0b661 100644
--- a/tavern/internal/www/schema.graphql
+++ b/tavern/internal/www/schema.graphql
@@ -635,6 +635,8 @@ type Task implements Node {
   execFinishedAt: Time
   """Output from executing the task"""
   output: String
+  """The size of the output in bytes"""
+  outputSize: Int!
   """Error, if any, produced while executing the Task"""
   error: String
   quest: Quest!
@@ -670,6 +672,7 @@ enum TaskOrderField {
   CLAIMED_AT
   EXEC_STARTED_AT
   EXEC_FINISHED_AT
+  OUTPUT_SIZE
 }
 """
 TaskWhereInput is used for filtering Task objects.
@@ -755,6 +758,15 @@ input TaskWhereInput {
   outputNotNil: Boolean
   outputEqualFold: String
   outputContainsFold: String
+  """output_size field predicates"""
+  outputSize: Int
+  outputSizeNEQ: Int
+  outputSizeIn: [Int!]
+  outputSizeNotIn: [Int!]
+  outputSizeGT: Int
+  outputSizeGTE: Int
+  outputSizeLT: Int
+  outputSizeLTE: Int
   """error field predicates"""
   error: String
   errorNEQ: String