diff --git a/cmd/dagger/cmd/up.go b/cmd/dagger/cmd/up.go
index b1b14a8f..925bf248 100644
--- a/cmd/dagger/cmd/up.go
+++ b/cmd/dagger/cmd/up.go
@@ -24,8 +24,6 @@ import (
 	"github.com/spf13/viper"
 )
 
-var withParams []string
-
 var upCmd = &cobra.Command{
 	Use:   "up",
 	Short: "Bring an environment online with latest plan and inputs",
@@ -144,7 +142,11 @@ func checkUniverseVersion(ctx context.Context, projectPath string) bool {
 func europaUp(ctx context.Context, cl *client.Client, args ...string) error {
 	lg := log.Ctx(ctx)
 
-	p, err := plan.Load(ctx, withParams, args...)
+	p, err := plan.Load(ctx, plan.Config{
+		Args: args,
+		With: viper.GetStringSlice("with"),
+	})
+
 	if err != nil {
 		lg.Fatal().Err(err).Msg("failed to load plan")
 	}
@@ -222,7 +224,7 @@ func checkInputs(ctx context.Context, env *environment.Environment) error {
 func init() {
 	upCmd.Flags().BoolP("force", "f", false, "Force up, disable inputs check")
 	upCmd.Flags().String("output", "", "Write computed output. Prints on stdout if set to-")
-	upCmd.Flags().StringArrayVarP(&withParams, "with", "w", []string{}, "")
+	upCmd.Flags().StringArrayP("with", "w", []string{}, "")
 
 	if err := viper.BindPFlags(upCmd.Flags()); err != nil {
 		panic(err)
diff --git a/plan/plan.go b/plan/plan.go
index 39398ffd..8f942d31 100644
--- a/plan/plan.go
+++ b/plan/plan.go
@@ -19,40 +19,46 @@ import (
 )
 
 type Plan struct {
+	config Config
+
 	context *plancontext.Context
 	source  *compiler.Value
 }
 
-func Load(ctx context.Context, withParams []string, args ...string) (*Plan, error) {
-	log.Ctx(ctx).Debug().Interface("args", args).Msg("loading plan")
+type Config struct {
+	Args []string
+	With []string
+}
+
+func Load(ctx context.Context, cfg Config) (*Plan, error) {
+	log.Ctx(ctx).Debug().Interface("args", cfg.Args).Msg("loading plan")
 
 	// FIXME: universe vendoring
 	if err := state.VendorUniverse(ctx, ""); err != nil {
 		return nil, err
 	}
 
-	v, err := compiler.Build("", nil, args...)
+	v, err := compiler.Build("", nil, cfg.Args...)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(withParams) > 0 {
-		for i, param := range withParams {
-			log.Ctx(ctx).Debug().Interface("with", param).Msg("compiling parameter")
-			paramV, err := compiler.Compile(fmt.Sprintf("with%v", i), param)
-			if err != nil {
-				return nil, err
-			}
+	for i, param := range cfg.With {
+		log.Ctx(ctx).Debug().Interface("with", param).Msg("compiling overlay")
+		paramV, err := compiler.Compile(fmt.Sprintf("with%v", i), param)
+		if err != nil {
+			return nil, err
+		}
 
-			log.Ctx(ctx).Debug().Interface("with", param).Msg("filling parameter")
-			fillErr := v.FillPath(cue.ParsePath(""), paramV)
-			if fillErr != nil {
-				return nil, fillErr
-			}
+		log.Ctx(ctx).Debug().Interface("with", param).Msg("filling overlay")
+		fillErr := v.FillPath(cue.ParsePath(""), paramV)
+		if fillErr != nil {
+			return nil, fillErr
 		}
 	}
 
 	p := &Plan{
+		config:  cfg,
 		context: plancontext.New(),
 		source:  v,
 	}