Python 3, 113 62 bytes

for i in[1]*3:x|={a+b for a in x for b in x}

while{i+1}&x:i+=1

Here x is the input as a set of ints, and i is the output.

Try it online!

(Thanks: Erik the Outgolfer, Mr. Xcoder, Lynn)

Jelly, 12 bytes

œċⱮ8Ẏ§ṢQJƑƤS

Try it online!

Takes on average ~3.7 seconds to run all test cases on TIO on my phone, so surprisingly it is quite fast.

Explanation

œċⱮ8Ẏ§ṢQJƑƤS     Monadic link / Full program.

  Ɱ8             Promote 8 to [1 ... 8] and for each value k:

œċ                    Generate all combinations of k elements from the list.

    Ẏ§           Tighten, then sum. Flatten to a 2D list then sum each.

      ṢQ         Sort the result and remove equal entries.

        JƑƤ      For each prefix of this list, return 1 if it is equal to its length range, 0 otherwise.

           S     Finally, sum the result (counts the 1's which is equivalent to what is being asked).

Haskell, 56 50 bytes

g c=[x|x<-[1..],all((/=x).sum)$mapM(0:)$c<$c]!!0-1

Try it online!

A brute force approach. Add 0 to the list of coins and try all combinations of 8 picks. Find the first number n that is not equal to the sum of any of the picks and return n-1.

Takes about 5m30s for [1, 2, 5, 13, 34, 89, 233, 610] on my 7 year old laptop hardware.

Edit: -6 bytes thanks to @Ørjan Johansen

An even shorter version (-2 bytes, again thanks to @Ørjan Johansen) is

Haskell, 48 bytes

g c=[x|x<-[1..],all((/=x).sum)$mapM(:0:c)c]!!0-1

but it uses significantly more memory and runs into heavy paging on my machine and does not finish "within a few minutes".

Jelly, 9 bytes

Żœċ8§ḟ’$Ṃ

Try it online!

How it works

Żœċ8§ḟ’$Ṃ  Main link. Argument: A (array)



Ż          Prepend a 0 to A.

 œċ8       Take all combinations of length 8, with repetitions.

    §      Take the sum of each combination.

       $   Combine the two links to the left into a monadic chain.

      ’      Decrement all sums.

     ḟ       Filterfalse; keep only sums that do not appear in the decremented sums.

        Ṃ  Take the minimum.

Wolfram Language (Mathematica), 53 bytes

LengthWhile[CoefficientList[(1+Tr[x^#])^8,x],#>0&]-1&

Try it online!

JavaScript (ES6),  100 88 80  76 bytes

This is essentially a brute-force search, but enhanced with pruning to speed it up. The average execution time for the test cases is close to 1 second on TIO.

Assumes that the input array is sorted from highest to lowest.

a=>[...Array(a[0]*9)].findIndex(g=(i=8,s)=>s*i>0?a.every(x=>g(i-1,s-x)):s)-1

Try it online!

Commented

a =>                      // a = input array

  [...Array(a[0] * 9)]    // create an array of 9 * max(a) entries

  .findIndex(             // find the position of the first truthy result

    g = (i = 8, s) =>     // g = recursive function taking a counter i, initialized to 8

                          //     and a sum s, initialized to the position in the above array

      s * i > 0 ?         //   if s is positive and i is not equal to 0:

        a.every(x =>      //     for each value x in a:

          g(i - 1, s - x) //       do a recursive call with i - 1 and s - x

        )                 //     end of every()

      :                   //   else:

        s                 //     yield s (s = 0 means success and makes findIndex go on)

  ) - 1                   // end of findIndex(); decrement the result

Python 2, 145 bytes

from itertools import*

x=set(map(sum,reduce(chain,map(combinations_with_replacement,[input()]*9,range(9)))))

print~-min(set(range(1,max(x)+2))-x)

Try it online!

Pari/GP, 57 bytes

a->n=-1;while(polcoeff((1+sum(i=1,8,x^a[i]))^8,n++),);n-1

Try it online!

Python 2, 125 115 111 bytes

lambda c:sum(i==j for i,j in enumerate(sorted(set(map(sum,product([0]+c,repeat=8))))))-1

from itertools import*

Try it online!

Expects a list of integers as input.

Explanation:

# an anonymous function

lambda c:

                                                          # get all length-8 combinations of values, from (0,0,0,0,0,0,0,0) to (8,8,8,8,8,8,8,8)

                                                          # zero is added to ensure that combinations of fewer than 8 coins are represented Ex:(1,0,0,0,0,0,0,0)

                                                          product([0]+c,repeat=8)

                                                  # for each combination, sum the values

                                                  map(sum,.......................)

                                       # get unique values, then sort them smallest to largest

                                       sorted(set(................................))

             # for each index, value pair, return if the index is equal to the value

             i==j for i,j in enumerate(.............................................)

         # in Python arithmetic, False is 0 and True is 1. So, count how many items match their index.

         # Since zero was added to the list, there will always be one extra match (0==0). So offset by one.

         sum(........................................................................)-1

from itertools import*

Perl6, 65 63 41 bytes (39 chars)

{@_=(0,|@_)X+(0,|@_)for ^3;($_ if $_==$++for @_.sort.unique)-1}

Try it online!

This is an anonymous block that gets passed its data as an array. The (0,|@_) is a quick way to add a 0 to @_, and even though it's done twice, it's still a bit shorter than @_.push: 0; which would then need spaces after the _. This is a brute force approach that cheeses a bit on the fact that it's 8 combinations. After cross adding, an anonymous list is created for sequential values. With math operators, lists evaluate to their length, so the -1 pulls double duty: accounting for the 0 and coercing to Int.

This can take its sweet time, but by changing one or both (0,|@_) to (0,|@_.unique) before the first for it can be sped up considerably. That adds +7 (runtime <60s) or +14 (runtime <10s) to the score if you feel the first is too slow (I did this for the linked code to avoid timeouts after 60 seconds).

Edit: JoKing in the comments improved it (same idea, cross add, then return the last consecutive result) to an astonishing 39 chars (41 bytes):

{(@_=@_ X+0,|@_)xx 1;first *+1∉@_,0..*}

Try it online!

The final tabulation doesn't need a 0, saving a few bytes by only needing to add 0 in once. The xx 3 mimics the for loop (still cheeses on the coins being a power of 2). The first sub returns the first number in the infinite list 0..* (^Inf is possible too, but doesn't save space) whose +1 is not a member of the cross added list. Like mine, it's slow, so add +7 for a unique after the first equals if you feel it's too slow for guidelines.

JavaScript (Node.js), 171 145 115 bytes

f=(s,n=3)=>n?f(s=new Set(a=[0,...s]),n-1,a.map(m=>a.map(n=>s.add(m+n)))):Math.min(...[...s].filter(m=>!s.has(m+1)))

Try it online! Port of @Mark's Python 3 answer. 108 bytes in Firefox 30-57:

f=(s,n=3)=>n?f(new Set((for(n of s=[0,...s])for(m of s)n+m)),n-1):Math.min(...[...s].filter(m=>!s.has(m+1)))

Clean, 161 bytes

import StdEnv,Data.List

$l=:[1:_]#k=sort(nub(map sum(iter 8(concatMap([h:t]=[[e,h:t]\e<-[0:l]|e>=h]))[[0]])))

=length(takeWhile((>=)1)(zipWith(-)(tl k)k))

$_=0

Try it online!