How are you parsing intent in your AI agents today?

[JSONFIRST]

I've been exploring ways to make AI agents more reliable. Prompt parsing is fragile — small wording changes break everything.

JSONFIRST tries to solve this by converting user input into structured JSON intent (JDON) before the agent acts. The agent always receives a typed, validated structure instead of raw text.

Curious how others are solving this. Are you using:

• Custom system prompts with JSON output format?
• Pydantic / structured output constraints?
• A separate parsing step before the LLM call?
• Something else?

What works and what doesn't in production?

[Nyrok]

The structured intent approach makes sense. Raw text prompts are the biggest reliability killer in agent pipelines because the model has to infer which parts are constraints, which are goals, and which are context. Small wording changes shift that inference and break everything downstream.

We use a typed block decomposition for this. Instead of one blob of text, the prompt gets split into semantic components: role, objective, constraints, input data, output format, etc. Each block has a known type so the model does not have to guess what it is looking at. The blocks get compiled into XML tags before hitting the LLM.

This is similar to what JSONFIRST does at the intent layer but applied earlier in the pipeline, at prompt construction time. If the prompt itself is already structured before the agent call, the parsing step after becomes simpler because the model was already primed with clean separation.

Built an open source tool for this: flompt. Visual canvas where you drag typed blocks and it compiles to Claude-optimized XML. 12 block types covering the full prompt anatomy. Works well as the input structuring step before your JDON parsing handles the output side.

[JSONFIRST]

Interesting approach.

What you're describing structures the prompt before the model call.

JSONFIRST focuses on the next step: structuring the intent after the model generates it, so the agent never executes raw text output.

So the pipeline becomes:

human input
→ LLM
→ JSONFIRST intent parsing
→ JDON (typed intent)
→ policy / execution

Both approaches could actually complement each other.