diff --git a/cue/ast.go b/cue/ast.go
index 6d6e8fa..3ff7483 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -345,6 +345,10 @@
 
 			case "len":
 				return lenBuiltin
+			case "and":
+				return andBuiltin
+			case "or":
+				return orBuiltin
 			}
 			if r, ok := predefinedRanges[n.Name]; ok {
 				return r
diff --git a/cue/builtin.go b/cue/builtin.go
index 02750f0..fa7e927 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -24,6 +24,7 @@
 	"path"
 	"sort"
 
+	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/parser"
 )
 
@@ -131,6 +132,41 @@
 	},
 }
 
+var andBuiltin = &builtin{
+	Name:   "and",
+	Params: []kind{listKind},
+	Result: intKind,
+	Func: func(c *callCtxt) {
+		iter := c.list(0)
+		if !iter.Next() {
+			c.ret = &top{baseValue{c.src}}
+			return
+		}
+		u := iter.Value().path.v
+		for iter.Next() {
+			u = mkBin(c.ctx, c.src.Pos(), opUnify, u, iter.Value().path.v)
+		}
+		c.ret = u
+	},
+}
+
+var orBuiltin = &builtin{
+	Name:   "or",
+	Params: []kind{stringKind | bytesKind | listKind | structKind},
+	Result: intKind,
+	Func: func(c *callCtxt) {
+		iter := c.list(0)
+		d := []dValue{}
+		for iter.Next() {
+			d = append(d, dValue{iter.Value().path.v, false})
+		}
+		c.ret = &disjunction{baseValue{c.src}, d}
+		if len(d) == 0 {
+			c.ret = errors.New("empty or")
+		}
+	},
+}
+
 func (x *builtin) kind() kind {
 	return lambdaKind
 }
@@ -176,6 +212,9 @@
 		}
 	}()
 	x.Func(&call)
+	if e, ok := call.ret.(value); ok {
+		return e
+	}
 	return convert(ctx, x, call.ret)
 }
 
diff --git a/cue/builtin_test.go b/cue/builtin_test.go
index 59c3e19..3b617ab 100644
--- a/cue/builtin_test.go
+++ b/cue/builtin_test.go
@@ -113,6 +113,21 @@
 	}, {
 		testExpr(`len('f\x20\x20')`),
 		`3`,
+	}, {
+		testExpr(`and([string, "foo"])`),
+		`"foo"`,
+	}, {
+		testExpr(`and([string, =~"fo"]) & "foo"`),
+		`"foo"`,
+	}, {
+		testExpr(`and([])`),
+		`_`,
+	}, {
+		testExpr(`or([1, 2, 3]) & 2`),
+		`2`,
+	}, {
+		testExpr(`or([])`),
+		`_|_(builtin:or:empty or)`,
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index 1e58e59..6a0db16 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -1311,6 +1311,32 @@
 		out: `<0>{obj: <1>{<>: <2>(Name: string)-><3>{a: (*"dummy" | string) if true yield ("sub"): <4>{as: <3>.a}}, ` +
 			`foo: <5>{a: "bar", sub: <6>{as: "bar"}}}}`,
 	}, {
+		desc: "builtins",
+		in: `
+		a1: {
+			a: and([b, c])
+			b: =~"oo"
+			c: =~"fo"
+		}
+		a2: a1 & { a: "foo" }
+		a3: a1 & { a: "bar" }
+
+		o1: {
+			a: or([b, c])
+			b: string
+			c: "bar"
+		}
+		o2: o1 & { a: "foo" }
+		o3: o1 & { a: "foo", b: "baz" }
+		`,
+		out: `<0>{` +
+			`a1: <1>{a: (=~"oo" & =~"fo"), b: =~"oo", c: =~"fo"}, ` +
+			`a2: <2>{a: "foo", b: =~"oo", c: =~"fo"}, ` +
+			`a3: <3>{a: _|_((=~"oo" & "bar"):"bar" does not match =~"oo"), b: =~"oo", c: =~"fo"}, ` +
+			`o1: <4>{a: string, b: string, c: "bar"}, ` +
+			`o2: <5>{a: "foo", b: string, c: "bar"}, ` +
+			`o3: <6>{a: _|_((builtin:or ([<7>.b,<7>.c]) & "foo"):empty disjunction: failed to unify: baz != foo), b: "baz", c: "bar"}}`,
+	}, {
 		desc: "self-reference cycles conflicts with strings",
 		in: `
 			a: {
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index 7cacb59..2dbc8ac 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -2251,6 +2251,28 @@
 len({a:1, b:2})      2
 ```
 
+### `and`
+
+The built-in function `and` takes a list and returns the result of applying
+the `&` operator to all elements in the list.
+It returns top for the empty list.
+
+Expression:          Result
+and([a, b])          a & b
+and([a])             a
+and([])              _
+
+### `or`
+
+The built-in function `or` takes a list and returns the result of applying
+the `|` operator to all elements in the list.
+It returns bottom for the empty list.
+
+Expression:          Result
+and([a, b])          a | b
+and([a])             a
+and([])              _|_
+
 
 ## Cycles