Jelly, 10 9 bytes

Ṫ=S×</=g/

Try it online!

How it works

Ṫ=S×</=g/  Main link. Argument: [a, b, c] (positive integers)



Ṫ          Tail; pop and yield c.

  S        Take the sum of [a, b], yielding (a + b).

 =         Yield t := (c == a + b).

    </     Reduce by less than, yielding (a < b).

   ×       Multiply, yielding t(a < b).

       g/  Reduce by GCD, yielding gcd(a, b).

      =    Check if t(a < b) == gcd(a, b).

Perl 6, 33 32 bytes

-1 byte thanks to nwellnhof

{(.sum/.[2]/2*[<] $_)==[gcd] $_}

Try it online!

Anonymous code block that takes a list of three numbers and returns True or False.

Explanation

{                              }  # Anonymous code block

                       [gcd] $_   # Is the gcd of all the numbers

 (                  )==           # Equal to

  .sum        # Whether the sum of numbes

      /       # Is equal to

       .[2]/2 # The last element doubled

             *[<] $_   # And elements are in ascending order

Haskell, 48 38 29 bytes

^{-10 bytes due to TFeld's gcd trick!}

^{-7 bytes thanks to HPWiz for improving the co-primality test and spotting a superfluous space!}

^{-2 bytes thanks to nimi for suggesting an infix-operator!}

(a!b)c=a<b&&a+b==c&&gcd a b<2

Try it online!

Explanation

The first two conditions a < b and a + b == c are fairly obvious, the third one uses that $gcd(a,b) = gcd(a,c) = gcd(b,c)$:

Writing $gcd(a,c) = U cdot a + V cdot c$ using Bézout's identity and substituting $c = a + b$ gives:

$$
U cdot a + V cdot (a + b) = (U + V) cdot a + V cdot b
$$

Since the $gcd$ is the minimal positive solution to that identity it follows that $gcd(a,b) = gcd(a,c)$. The other case is symmetric.

Java 10, 65 64 bytes

(a,b,c)->{var r=a<b&a+b==c;for(;b>0;a=b,b=c)c=a%b;return r&a<2;}

-1 byte thank to @Shaggy.

Try it online.

Explanation:

(a,b,c)->{        // Method with three integer parameters and boolean return-type

  var r=          //  Result-boolean, starting at:

        a<b       //   Check if `a` is smaller than `b`

        &a+b==c;  //   And if `a+b` is equal to `c`

  for(;b>0        //  Then loop as long as `b` is not 0 yet

      ;           //    After every iteration:

       a=b,       //     Set `a` to the current `b`

       b=c)       //     And set `b` to the temp value `c`

    c=a%b;        //   Set the temp value `c` to `a` modulo-`b`

                  //   (we no longer need `c` at this point)

  return r        //  Return if the boolean-result is true

         &a<2;}   //  And `a` is now smaller than 2

05AB1E, 12 11 10 bytes

Saved 1 byte thanks to Kevin Cruijssen

ÂÆ_*`‹*¿Θ

Try it online!
or as a Test Suite

Explanation

ÂÆ           # reduce a reversed copy of the input by subtraction

  _          # logically negate

   *         # multiply with input

    `        # push the values of the resulting list separately to stack

            # remove the top (last) value

      ‹      # is a < b ?

       *     # multiply by the input list

        ¿    # calculate the gcd of the result

         Θ   # is it true ?

Python 2, 69 67 63 62 55 bytes

lambda a,b,c:(c-b==a<b)/gcd(a,b)

from fractions import*

Try it online!

Python 3, 58 51 bytes

lambda a,b,c:(c-b==a<b)==gcd(a,b)

from math import*

Try it online!

_{-7 bytes, thanks to H.PWiz}

Japt, 16 14 13 11 bytes

<V¥yU «NÔr-

Try it

                :Implicit input of integers U=A, V=B & W=C

<V              :Is U less than V?

  ¥             :Test that for equality with

   yU           :The GCD of V & U

      «         :Logical AND with the negation of

       N        :The array of inputs

        Ô       :Reversed

         r-     :Reduced by subtraction

JavaScript (ES6),  54 43 42  40 bytes

Thanks to @Shaggy for pointing out that we don't need to compute $gcd(a,c)$. Saved 11 bytes by rewriting the code accordingly.

Takes input as 3 separate integers. Returns $true$ for an ABC-triple, or either $0$ or $false$ otherwise.

f=(a,b,c)=>c&&a/b|a+b-c?0:b?f(b,a%b):a<2

Try it online!

Excel, 33 bytes

=AND(A1+B1=C1,GCD(A1:C1)=1,A1<B1)

bash, 61 bytes

factor $@|grep -vzP '( .+b).*n.*1b'&&(($1<$2&&$1+$2==$3))

Try it online!

Input as command line arguments,
output in the exit code
(also produces output on stdout as a side effect, but this can be ignored).

The second part (starting from &&(() is pretty standard,
but the interesting bit is the coprime test:

factor $@      # produces output of the form "6: 2 3n8: 2 2 2n14: 2 7n"

|grep -        # regex search on the result

v              # invert the match (return truthy for strings that don't match)

z              # zero-terminated, allowing us to match newlines

P              # perl (extended) regex

'( .+b)'      # match one or more full factors

'.*n.*'       # and somewhere on the next line...

'1b'         # find the same full factors

Wolfram Language 24 30 28 bytes

With 2 bytes saved by Doorknob,

#<#2&&CoprimeQ@##&&#+#2==#3&

C# (Visual C# Interactive Compiler), 59 bytes

(a,b,c)=>Enumerable.Range(2,a).All(i=>a%i+b%i>0)&a<b&a+b==c

Try it online!

J, 27 bytes

(+/=2*{:)*({.<1{])*1=+./ .*

Try it online!

Inspired by Jo King's Perl solution

C# (Visual C# Interactive Compiler), 90 bytes

n=>new int[(int)1e8].Where((_,b)=>n[0]%++b<1&n[1]%b<1).Count()<2&n[0]+n[1]==n[2]&n[0]<n[1]

Runs for numbers up to 1e8, takes about 35 seconds on my machine. Instead of calculating the gcd like others, the function just instantiate a huge array and filter the indexes that aren't divisors of a or b, and check how many elements are left. Next it check if element one plus element two equals element three. Lastly, it checks if the first element is less than the second.

Try it online!

C# (.NET Core), 68 bytes

Without Linq.

(a,b,c)=>{var t=a<b&a+b==c;while(b>0){c=b;b=a%b;a=c;}return t&a<2;};

Try it online!

Stax, 12 bytes

ü╡v╕7+Pü°╔|g

Run and debug it

Pari/GP, 30 bytes

Saved 2 bytes thanks to @Shaggy.

(a,b,c)->a<b==gcd(a,b)&&a+b==c

Try it online!

Clean, 43 bytes

import StdEnv

$a b c=a<b&&a+b==c&&gcd a b<2

Try it online!

Similar to basically everything else because the direct test is the same.

Retina 0.8.2, 40 bytes

d+

$*

A`^(11+)+,1+,

^(1+),(1+1),12$

Try it online! Link includes test cases. Explanation:

d+

$*

Convert to unary.

A`^(11+)+,1+,

Check that A and B have no common factor.

^(1+),(1+1),12$

Check that A < B and A + B = C.

Befunge-98 (FBBI), 83 bytes

&:&:03p&:04pw>03g04g:v_1w03g04g+w1.@

00:    7j@.0[^j7      _^;>0.@;j7;>0.@;:%g00p

Try it online!

The input which is a triple of integers [A,B,C] is feeded into Befunge as space-separated integers C B A.