Wolfram Language (Mathematica), 34 bytes

0~Range~19~Binomial~i~Sum~i,0,#&

Try it online!

The tier $n$ metasequence is the sum of the first $n+1$ elements of each row of the Pascal triangle.

Haskell, 35 bytes

take 20.(iterate(scanl(+)1)[1..]!!)

Try it online! Uses 0-indexed inputs (f 4 returns tier 5.)

Haskell, 36 bytes

f 1=[1..20]
f n=init$scanl(+)1$f$n-1

Try it online! Uses 1-indexed inputs (f 5 returns tier 5.)

Explanation

scanl (+) 1 is a function that takes partial sums of a list, starting from (and prepending) 1.

For example: scanl (+) 1 [20,300,4000] equals [1,21,321,4321].

It turns out that tier $n$ is just this function applied $ (n-1) $ times to the list $[1,2,3,dots]$.

(Or equivalently: $n$ times to a list of all ones.)

We use either init or [1..20-n] to account for the list getting longer by $1$ every application.

Jelly, 8 7 bytes

20ḶcþŻS

Try it online!

 cþ Table of binom(x,y) where:
20Ḷ x = [0..19]
 Ż y = [0..n] e.g. n=3 → [[1, 1, 1, 1, 1, 1, …]
 [0, 1, 2, 3, 4, 5, …]
 [0, 0, 1, 3, 6, 10, …]
 [0, 0, 0, 1, 4, 10, …]]

 S Columnwise sum. → [1, 2, 4, 8, 15, 26, …]

This uses @alephalpha’s insight that $$textmeta-sequence_n(i) = sum_k=0^n binom ik.$$

Python 2, 69 58 55 bytes

Saved bytes thanks to ovs and Jo King; also, it works in Python 3 now as well.

m=lambda t:[1+sum(m(t-1)[:n])for n in range(~t and 20)]

Try it online!

The math

Let $a(t,n)$ be the $n^th$ term (0-indexed) of the sequence at tier $t$. A little analysis leads to the following recurrence formula:

$$
a(t,n) = 1+sum_i=0^n-1a(t-1,i)
$$

Working backwards, we define $a(0,n) = 1$ and $a(-1,n) = 0$ for all $n$. These definitions will simplify our base case.

The code

We define a function m(t) that returns the first 20 elements of the sequence at tier t. If t is nonnegative, we use the recursive formula above; if t is -1, we return an empty list. The empty list works as a base case because the result of each recursive call is sliced ([:n]) and then summed. Slicing an empty list gives an empty list, and summing an empty list gives 0. That's exactly the result we want, since tier $-1$ should behave like a constant sequence of all $0$'s.

m=lambda t: # Define a function m(t):
 [ ] # List comprehension
 for n in range( ) # for each n from 0 up to but not including...
 ~n and 20 # 0 if n is -1, else 20:
 1+sum( ) # a(t,n) = 1 + sum of
 [:n] # the first n elements of
 m(t-1) # the previous tier (calculated recursively)

Brain-Flak, 84 82 bytes

<>((()()()()()))([((()))])<>([(())]<<>(<>())<><>(<>)<>>)<>

Try it online!

Annotated

<> Switch to the off stack
((()()()()())) Push 10
([((()))]) Make twice that many 1s
<> Switch back
 While ...
([(())]< Subtract one from the input and push 1
<> Switch
 For every x on the stack
(<>())<> Remove x and add it to a copy of the other TOS
 End loop
<> Remove 1 element to keep it 20
(<>)<> Copy everything back to the other stack
>)<> End scopes and loops

Try it online!

R, 36 bytes

rowSums(outer(0:19,0:scan(),choose))

Try it online!

Thanks to @Giuseppe for suggesting outer.

This is based on the approach @alephalpha described

dzaima/APL REPL, 14 bytes

(+1,19↑)⍣⎕⍳20

Try it online!

(+1,19↑)⍣⎕⍳20
( )⍣⎕ repeat the function below input times:
 + cumulative sum of
 1, 1 prepended to
 19↑ the first 19 items of the previous iteration
 ⍳20 starting with the first 20 integers

Pari/GP, 39 bytes

n->Vec(sum(i=1,n+1,(1/x-1)^-i)+O(x^21))

Try it online!

Pari/GP, 40 bytes

n->Vec((1-(1/x-1)^-n++)/(1-2*x)+O(x^20))

Try it online!

The generating function of the tier $n$ metasequence is:

$$sum_i=0^nfracx^i(1-x)^i+1=frac1-left(fracx1-xright)^1+n1-2x$$

Perl 6, 34 32 bytes

-2 bytes thanks to Jo King

(@,[+] 1,...*)[$_+1]

Try it online!

Explanation

 # Anonymous block
 , ...* # Construct infinite sequence of sequences
 @ # Start with empty array
 # Compute next element as
 [+] # cumulative sum of
 1, # one followed by
 |.[^19] # first 19 elements of previous sequence
 ( )[$_+1] # Take (n+1)th element

Python 3.8 (pre-release), 62 bytes

f=lambda n:[t:=1]+[t:=t+n for n in(n and f(n-1)[:-1]or[0]*19)]

Try it online!

Explanation

f=lambda n: # funtion takes a single argument
 [t:=1] # This evaluates to [1] and assigns 1 to t
 # assignment expressions are a new feature of Python 3.8
 + # concatenated to
 [ .... ] # list comprehension

# The list comprehesion works together with the
# assignment expression as a scan function:
[t := t+n for n in it]
# This calculates all partial sums of it 
# (plus the initial value of t, which is 1 here)

# The list comprehension iterates
# over the first 19 entries of f(n-1)
# or over a list of zeros for n=0
 for n in (n and f(n-1)[:-1] or [0]*19)

R (63 47 bytes)

function(n,k=0:19)2^k*pbeta(.5,pmax(k-n,0),n+1)

Online demo. This uses the regularised incomplete beta function, which gives the cumulative distribution function of a binomial, and hence just needs a bit of scaling to give partial sums of rows of Pascal's triangle.

Octave (66 46 bytes)

@(n,k=0:19)2.^k.*betainc(.5,max(k-n,1E-9),n+1)

Online demo. Exactly the same concept, but slightly uglier because betainc, unlike R's pbeta, requires the second and third arguments to be greater than zero.

Many thanks to Giuseppe for helping me to vectorise these, with significant savings.

Ruby, 74 bytes

a=->bc=[1];d=0;b==1?c=(1..20).to_a: 19.timesc<<c[d]+(a[b-1])[d];d+=1;c

Ungolfed version:

def seq num
 ary = [1]
 index = 0
 if num == 1
 ary = (1..20).to_a
 else
 19.timesary << ary[index]+seq(num-1)[index]; index+=1
 end
 return ary
end

Quite resource-intensive--the online version can't calculate the 13th metasequence.

Try it online

Wolfram Language (Mathematica), 42 bytes

Nest[FoldList[Plus,1,#]&,Range[21-#],#-1]&

Try it online!

05AB1E, 11 9 bytes

20LIF.¥>¨

0-indexed

Try it online or verify all test cases.

Explanation:

20L # Create a list in the range [1,20]
 IF # Loop the input amount of times:
 .¥ # Get the cumulative sum of the current list with 0 prepended automatically
 > # Increase each value in this list by 1
 ¨ # Remove the trailing 21th item from the list
 # (after the loop, output the result-list implicitly)

JavaScript (ES6),  68  67 bytes

f=(n,a=[...f+f])=>n--?f(n,[s=1,...a.map(x=>s-=~--x)]):a.slice(0,20)

Try it online!

JavaScript (ES6), 63 bytes

NB: this version works for $nle20$.

f=(n,a=[...Array(20-n)])=>n--?f(n,[s=1,...a.map(x=>s+=x||1)]):a

Try it online!

J, 24 bytes

<:(1+/@,])^:[(1+i.20)"_

Try it online!

NOTE: Turns out this is a translation of dzaima's APL answer, though I actually didn't notice it before writing this.

explanation

<: (1 +/@, ])^:[ (1+i.20)"_
<: NB. input minus 1 (left input)
 (1+i.20)"_ NB. 1..20 (right input)
 ( )^:[ NB. apply verb in parens 
 NB. "left input" times
 (1 , ]) NB. prepend 1 to right input
 ( +/@ ) NB. and take scan sum

Ruby, 49 bytes

f=->nn<1?[1]*20:[o=1]+f[n-1][0,19].mapx

Recursive definition: Tier 0 is 1,1,1,1... and each subsequent tier is 1 followed by a sequence whose first differences are the previous tier. Annoyingly this would give me 21 values if I didn't explicitly slice out the first 20; seems like there should be a way to shorten this by avoiding that.

Retina, 59 bytes

.+
19*$(_,

Replace the input with 19 1s (in unary). (The 20th value is 0 because it always gets deleted by the first pass through the loop.)

"$+" 
 
 

Rust, 135 bytes

fn t(m:u64)->Vec<u64>a*n);(0..20).map(

used @alephalpha 's idea, like several others. there is no builtin factorial so that takes up at least 36 bytes, (plus dealing with negatives). no builtin choose, another 16 bytes. iterator->declared vector type, 20 bytes.. etc etc.

Ungolfed at play.rust-lang.org

Wolfram Language (Mathematica), 34 bytes

0~Range~19~Binomial~i~Sum~i,0,#&

Try it online!

The tier $n$ metasequence is the sum of the first $n+1$ elements of each row of the Pascal triangle.

Haskell, 35 bytes

take 20.(iterate(scanl(+)1)[1..]!!)

Try it online! Uses 0-indexed inputs (f 4 returns tier 5.)

Haskell, 36 bytes

f 1=[1..20]
f n=init$scanl(+)1$f$n-1

Try it online! Uses 1-indexed inputs (f 5 returns tier 5.)

Explanation

scanl (+) 1 is a function that takes partial sums of a list, starting from (and prepending) 1.

For example: scanl (+) 1 [20,300,4000] equals [1,21,321,4321].

It turns out that tier $n$ is just this function applied $ (n-1) $ times to the list $[1,2,3,dots]$.

(Or equivalently: $n$ times to a list of all ones.)

We use either init or [1..20-n] to account for the list getting longer by $1$ every application.