Linear logic is very valuable in the theory of programming languages, so one way of looking at your question is to see what value these new models have in terms of programming languages.

Most of the usefulness of models of programming languages lies in the "tension" between syntax and semantics. Here are a few items reflecting this tension (without pretension of being exhaustive) :

**negative results about expressiveness:** by showing that a programming language has a model in which a certain feature does not exist, you show that that feature is not expressible in the syntax of the language. This has been done occasionally ("parallel or" in the $\lambda$-calculus, for example).
**full abstraction:** it's a crucial problem of programming languages theory: find a model of a given programming language equating exactly those programs which are observationally equivalent in some given sense. This is one way of saying that syntax and semantics perfectly match.
**full completeness:** this is when the interpretation functor is full: given two types $A,B$, each map $[A]\to[B]$ in the model corresponds to a program $A\to B$ in the programming language (or to a proof of the logical system).
**new programming constructs:** if the model is not fully abstract or fully complete, then it has "more stuff" than the syntax. What is this extra stuff? Is it computationally interesting?
**finer interpretation of the syntax:** maybe your model does not really add expressiveness but it provides an interpretation of the syntax which is interesting in its own way, for example because it suggests that certain features of the language may be expressed as composition of simpler features.
**quantitative features:** in many cases, models of linear logic have the ability to say something quantitative about the dynamics of programs, e.g., how many steps does it take to reach a normal form? Maybe your models can be interesting in this sense.
**pure $\lambda$-calculus:** this is more of a "niche" topic, but there are people who are interested in so called *$\lambda$-theories* (congruences on untyped $\lambda$-terms including $\beta$-equivalence) and with finding models yielding exactly a given $\lambda$-theory (I think there are open problems in this respect). If the Kleisli category of the comonad interpreting $!(-)$ in your model has a reflexive object (this is not always the case), then you have a model of the untyped $\lambda$-calculus and this model induces a $\lambda$-theory. It might be an interesting one!

In most cases, as you say, one builds a model with one of the above points in mind. For example, one has a language with certain features (non-determinism, probabilistic execution, quantum programming...) and tries to build a model of linear logic capable of interpreting those features. Or, in the other direction, one wants to build a model based on certain mathematical structures, and then import those structures in the syntax (this was the case of differential linear logic). Examples of the fifth bullet point are rare: linear logic itself was born in that way, another example is the study of polarity in linear logic via models in which connectives decompose through a polarity change.

Finally, a good idea is to go talk directly with experts in models of linear logic who are near you and are not present on MathOverflow. In your case, the first name that comes to my mind is Thomas Ehrhard. For what concerns models of the $\lambda$-calculus, an expert is Giulio Manzonetto. They are both in Paris and will be happy to take a look at your new models!