How to stop Self Intersection of Model?
This solution really worked great for me. It is developed in python, the code is kind of long but the ideas are pretty simple.

First I found the global head and tail locations of each bone.

My solution to self-intersection detection between fingers and the palm is pretty straightforward. I checked the distance of each fingertip tail bone to a plane created from three points in the palm. This is the function that I built.

def getPointToSurfDist(testBone, triBones):
    #points for surface
    p1 = getBoneGlobalTailLocation(getBoneObByName(triBones[0]))
    p2 = getBoneGlobalTailLocation(getBoneObByName(triBones[1]))
    p3 = getBoneGlobalTailLocation(getBoneObByName(triBones[2]))
    #vectors
    v1 = p2-p1
    v2 = p3-p1
    #3D plane
    s1 = v1.cross(v2)
    #test point
    p4 = getBoneGlobalTailLocation(getBoneObByName(testBone))
    dis = (s1.x*p4.x + s1.y*p4.y + s1.z*p4.z)/math.sqrt(math.pow(s1.x,2)+math.pow(s1.y,2)+math.pow(s1.z,2))
    return dis


If the distance was below a certain threshold the fingers were considered to intersect the palm.

My solution to the finger-to-finger intersection is a bit more interesting and less trivial. I decided to look at each armature bone as a finite segment. Then I check the distance between each segment and all of the other segments. I have about 20 armature bones, translating into a cap of approximately 400 calculations (not too bad, very fast). If the minimum distance between two armature bones was under a given threshold it would be considered intersecting.

I translated the dist3D_Segment_to_Segment() function from:
http://geomalgorithms.com/a07-_distance.html 
to python and applied in my code. 
(look here to further understand the code.)

def getSeg2SegDistance(hs1,ts1,hs2,ts2):
    #implementation converted from C: http://geomalgorithms.com/a07-_distance.html
    #input heads and tails of both segments (head s1, tail s1, head s2, tail s2)
    #initialize vectors
    u = ts1 - hs1
    v = ts2 - hs2
    w = hs1 - hs2
    a = u.dot(u)
    b = u.dot(v)
    c = v.dot(v)
    d = u.dot(w)
    e = v.dot(w)
    D = a*c - b*b
    sc, sN, sD = [D, D, D]
    tc, tN, tD = [D, D, D]
    #compute the line parameters of the two closest points
    smallApproxErr = 0.01
    if D &lt; smallApproxErr: #lines approx parallel
        sN = 0.0
        sD = 1.0
        tN = e
        tD = c
    else:               #closest point on infinite lines
        sN = b*e - c*d
        tN = a*e - b*d
        if sN&lt;0.0:      #sc&lt;0 -&gt; s=0
            sN = 0.0
            tN = e
            tD = c
        elif sN &gt; sD:   #sc&gt;1 -&gt; s=1
            sN = sD
            tN = e + b
            tD = c
    if tN &lt; 0.0:        #tc&lt;0 -&gt; t=0
        tN = 0.0
        if (-d&lt;0.0):
            sN = 0.0
        elif (-d&gt;a):
            sN = sD
        else:
            sN = -d
            sD = a
    elif tN &gt; tD:       #tc&gt;1 -&gt; t=1
        tN = tD
        if -d + b &lt; 0.0:
            sN = 0
        elif -d +b &gt; a:
            sN = sD
        else:
            sN = -d + b
            sD = a
    #division to get sc and tc
    if abs(sN) &lt; smallApproxErr:
        sc = 0
    else:
        sc = sN/sD
    if abs(tN) &lt; smallApproxErr:
        tc = 0
    else:
        tc = tN/tD

    dP = w + sc*u - tc*v
    return math.sqrt(dP.dot(dP))


This intersection detection works great. It is not a general solution to every armature rig self-intersection detection, yet for hands/ arms/ machines (with bars or pipes) this would work great. The idea can further be generalized taking into account the 'Envelope Radius' of the bones to effect the thresholding. It is useful to think about the distance calculation from the body you are rigging.

This solution is python based and really gets into the geometry. A simple solution from within the blender platform would still be nice

Good luck!