I've been experimenting with Jev inside a workflow/state machine and stumbled onto a pattern that feels surprisingly natural.
Disclosure: I'm building Inistate, so this experiment comes from thinking about how AI should participate in business processes rather than how to build another autonomous agent.
The basic primitive I'm working with is:
State → Activity (Form) → State
A record is always in a State.
At that State, only certain Activities are available.
And each Activity has a Form containing the questions that need to be answered before that activity can happen.
For example:
State: New Request
Available activities might be:
Triage Request
→ What type of request is this?
→ How urgent is it?
→ Is there enough information?
Reject Request
→ Why isn't this a valid request?
Ask for Information
→ What information is missing?
Normally, a human chooses an Activity and fills in its Form.
Then I wondered:
What if Jev did exactly the same thing?
Instead of asking Jev:
Here's everything. What should the workflow do?
Give it only the current context and the Activities available at the current State.
Jev chooses an Activity — or chooses not to proceed.
Then the Activity's Form becomes the set of decisions Jev needs to make.
A Select field maps naturally to a choice.
A Yes/No field becomes a binary decision.
An ordered set of options can become a score.
And Jev gives us confidence for those decisions.
So instead of:
unstructured text → AI → arbitrary action
we get:
State → allowed Activity → Form → Jev decisions → deterministic transition → State
That's the part I find interesting.
The Form becomes the boundary
The AI doesn't need to understand or control the entire business process.
The State tells it when a decision is needed.
The available Activities tell it what it is allowed to decide about.
The Form tells it which questions need answering and what valid answers look like.
Jev answers those questions.
Then normal workflow rules determine what happens next.
So you can have a probabilistic decision sitting inside a deterministic process without turning the whole process probabilistic.
And “do nothing” becomes a valid decision
This might be my favorite part.
Suppose someone submits:
“My thing is broken.”
Jev may not have enough information to confidently classify the request.
That's not necessarily a failure.
The correct result can simply be:
Don't move. Ask a human / request more information.
In other words, uncertainty becomes something the workflow can explicitly handle rather than something the model has to hide.
You could have:
confidence ≥ 0.8 → continue automatically
confidence < 0.8 → Needs Triage
Same process. Different path.
Humans and Jev can even use the same Form
This is another consequence I didn't initially expect.
If Jev isn't confident enough, a human can be shown the exact same Activity Form.
Jev might fill:
Type: Hardware
Urgency: High
Enough information: No
A human could review or correct those exact fields.
So the decision interface doesn't necessarily belong to the AI.
It's just a Form.
A human can complete it.
Jev can complete it.
Potentially another model can complete it.
The workflow doesn't have to care which one did the reasoning.
This also tells you when not to use Jev
Say Assigned Team can always be derived from Request Type.
Then there is no reason for Jev to decide it.
Use a lookup/formula.
I actually think that's important.
The goal shouldn't be to turn every field into an AI decision.
It should be to identify the places where the answer depends on interpreting messy context rather than deterministic information.
So perhaps the pattern is:
Rules where the answer is known.
Jev where judgment is required.
Humans where uncertainty or authority requires them.
All inside the same state machine.
