How do I describe a DFA?
Notice that it's not unreasonable to slightly extend this problem to an arbitrary number of triples. For example, the single triplet [123] is a reasonable candidate to be in your language, since $1+2=3$. Similarly, [280][135] is another reasonable candidate, since $12+38=50$. With that in mind, I'll extend the language to all strings of an arbitrary number (including zero) of triples that satisfy the summation requirement. I'll also decide that we'll accept a sequence of triplets only if they represent a sum without a final carry, so we wouldn't accept the string [000][000][190] since $100+900=1000$ and there's a final carry out (though [000][000][190][001] would be accepted).

The fundamental idea is a very common one: "remember" the current state of the problem by using one state in the DFA for each possible configuration. Here's what we might do:


Label the start state $start$. We haven't read any input yet. This will also be the unique final state.
Let state $t$ remember that we've seen the first [, so we have the move $\delta(start, [)=t$.
Next, construct ten states $p_0, p_1, \dotsc,p_9$ to remember the first digit. We'll have the moves $\delta(t,i)=p_i$, i.e., from $t$ we'll be in state $p_i$ after having seen input $i$. 
Now make twenty more states, $q_0, \dotsc,q_9$ and $c_0,\dotsc,c_9$. The $q$'s will record the sum of the first two inputs if there's no carry and the $c$'s will record the sum if there is a carry. In other words
$$
\delta(p_i,j) =\begin{cases}
                  q_{i+j} &amp;\text{if } i+j\le 9\\
                  c_{(i+j)\bmod{10}} &amp;\text{if } i+j\ge 10
               \end{cases}
$$
Then make two states, $a,b$ to note whether the third input is the sum of the first two and wehther or not we've generated a carry. From state $q_k$ (sum is $k$ with no carry) we'll pass to state $a$ if the third input is the digit $k$. Similarly, we'll have $\delta(c_k,k)=b$ meaning that we've just seen the appropriate third digit and we had a carry.
Now we've read the first triplet and we're expecting to see a ]. In state $a$ we know we've completed the first triplet and don't have to adjust any subsequent triplet, so $\delta(a,]) = start$, i.e., we loop back to the start and accept if there's no further input. On the other hand, if we're in state $b$ then we have a correct digit sum, but we also have a carry, so we can't yet accept when we see a ], instead we need to read another triplet. We'll process the ], read a [ and duplicate the whole process again, this time adjusting for the carry. We'll then have $\delta(b, ])=u$ and $\delta(u,[)=v$.
Starting anew from state $v$, we construct 34 new states exactly as we did in steps (1) - (6). The only difference is that the transitions from the new states corresponding to the original $p$ states (call them $p'_i$) in step (4) we'll compensate for the previous carry in and have
$$
\delta(p_i,j) =\begin{cases}
                  q_{i+j+1} &amp;\text{if } i+j+1\le 9\\
                  c_{(i+j+1)\bmod{10}} &amp;\text{if } i+j+1\ge 10
               \end{cases}
$$
The final difference with these new states is that if we get to the new state, $b'$ corresponding to the original $b$, then on seeing ], we go back to state $start'$ and start again.




In high-level terms, we have two nearly-identical functions to check whether a triplet $t$ is valid:


$N(t)$ which checks whether $t$ is valid, assuming no carry in. This will return 0 or 1, depending on whether or not $t$ generated a carry.
$C(t)$ which checks whether $t$ is valid, assuming a carry in. This will return 0 or 1, depending on whether or not $t$ generated a carry.


Then, we would have the following pseudocode

c = 0
while there's a triplet t to process
   get t
   if c = 0
      c = N(t)
   else
      c = C(t)
end loop
if c = 0
   accept
else
   reject