The following function defines the function gpf(ax+b) where "x" is the independent variable of the function and "a" and "b" are parameters that are set before computation over the domain of "x"s.

gpf[x_,a_,b_]:=
(
primefactorization=FactorInteger[a*x+b];
primefactors={};
n=1;
m=Length[primefactorization];While[n<m+1,primefactors=Append[primefactors,Part[Part[primefactorization,n],1]];
n++];
Max[primefactors]
)

Some examples computing with this function follow. To find the greatest prime factor of 8 we would use

gpf[8,1,0]

since it is computing by definition gpf(8*1+0)=gpf(8). So we could achieve the same computation by using, say

gpf[5,1,3]

since by definition this code computes gpf(5*1+3)=gpf(8).
---------------------------------------------------------------------------------------------------

Shown below is a plot of the function gpf(n) for n=1 to n=m (m defined by the slider).

Manipulate[DiscretePlot[gpf[n,1,0],{n,1,m},Filling->None, Joined->False],{m,1,10000,1}]

Shown below are maniuplators where we vary the three parameters of the function gpf(an+b) for inputs n=1 to n=1000.

Manipulate[DiscretePlot[gpf[a*n+b,1,0],{n,1,m},Filling->None, Joined->False],{m,1,10000,1},{a,1,1000,1},{b,1,100,1}]

gpf[803,3,1]

gpf[68,3,1]

The following functions create so-called gpf sequence graphs. The generategraphinputs function does as expected and primeplot actually plots them. gpfplot puts it all together into a tidy package.Since after one iteration of the algorithm we end up with primes anyway, we restrict our function to iterate over the set of primes rather than the set of natural numbers. This reduces some complexity and probably does not affect the results too much, as any loop (the focus of our investigation) must consist only of primes.

generategraphinputs[p_,a_,b_]:=
(
graphinputs={p};
While[MemberQ[graphinputs,gpf[Last[graphinputs],a,b]]==False, graphinputs=Append[graphinputs,gpf[Last[graphinputs],a,b]];]
)

primeplot[p_,a_,b_]:=
(
graphmatrix={};
generategraphinputs[p,a,b];
iterator=1;
While[
iterator<Length[graphinputs]+1,
graphmatrix=Append[graphmatrix,Part[graphinputs,iterator]-> gpf[Part[graphinputs,iterator],a,b]];
iterator++
];
Return[graphmatrix];
)

gpfplot[totalprimes_,a_,b_]:=
(
finalgraphmatrix={};
gpfplotiterator=1;
While[
gpfplotiterator<Prime[totalprimes],
finalgraphmatrix=Union[finalgraphmatrix,primeplot[Prime[gpfplotiterator],a,b]];
gpfplotiterator++
];
Return[GraphPlot[finalgraphmatrix,DirectedEdges-> True]];
)

Shown below is a maniuplator that shows us the totality of the gpf(a*p+b) graph for a given number of primes, n. We are allowed to manipulate all the parameters.

Manipulate[gpfplot[n,a,b],{{a,1,"a"},1,130,1},{{b,1,"b"},1,130,1},{{n,1,"n"},1,100,1}]

I noticed a pattern that the connected components of the graph of gpf(ap+a) is 1. Is that true? We can manipulate a graph to check! 
So far letting n vary from 1 to 100 seems to keep it a single component.

Manipulate[gpfplot[100,a,a],{{a,1,"a"},1,100,1}]

Manipulate[gpfplot[100,a,a+1],{{a,1,"a"},1,100,1}]

Below is a first stab at a generalization of the problem to rational numbers.

gpfq[q_,a_,b_]:=
(
gpf[Numerator[q]] * gpf[Denominator[q]]
)

gpfq[2/3]

Manipulate[gpfplot[n,a,b],{{a,1,"a"},1,130,1},{{b,1,"b"},1,130,1},{{n,1,"n"},1,100,1}]

Below is a plot of the summation function of gpf(n)...i.e. \sum_{k=1}^m gpf(k).

Manipulate[DiscretePlot[Sum[gpf[k,1,100],{k,1,j}],{j,1,m},Filling->None, Joined->False],{m,1,1000,1}]