Three Jev Experiments: Where Fast Semantic Judgments Belong

Generated with Ai based on meetings and conversations of Dave Nellis and Dekan Brown

I spent time with Jev in three places that look unrelated: a tank arena, a maze, and a community-memory pilot. The useful result was consistent. Let code own mechanics and records. Ask Jev a narrow, typed question where interpreting context is the hard part. Keep uncertainty and evidence attached.

That is a smaller claim than “a model can run the game” or “a memory system knows who owns what.” It turned out to be the useful one.

1. Doctrine: Jev picks the state, not the physics

Doctrine began as a playable local tank arena: cover, player controls, shooting, damage, and round end. The enemy already had an ordinary finite-state machine with three doctrines—cautious veteran, berserker, and ambusher. The experiment was to replace the if-ladder that selects the active doctrine, not the simulation itself.

Jev selected the local state.

That boundary was earned through failure. A berserker drove into walls. Sending more map data, bullet positions, and tank coordinates did not solve the problem; the model still could not reliably calculate geometry from a fat state payload. The game needed derived facts, not a bigger prompt: which directions were open, whether cover was available, whether an escape route existed. A small client-side steering function still handled obstacle avoidance.

Once the division was clear, the loop got more playable. Jev chose flank, flee, or cautious behavior; local code moved the tank and enforced the rules. In earlier experimentation, Dave ran the picker more than five times a second at roughly $0.04 per session. Those are field observations, not a performance guarantee; the public repository’s current cadence is 350 ms, or about 2.9 calls per second.

The point was not that Jev was a better game AI. A fast decision model may fit a problem with messy state and a small legal action set. A fast decision model may fit a problem with messy state and a small legal action set.

2. The maze: from arbitrary symbols to actual meaning

We then built a local canvas maze app with repeatable seeds, configurable clues, and paired solvers. JavaScript handled visited cells, cycle avoidance, and DFS backtracking for every solver. Jev only chose among multiple unexplored exits.

The first test used zigzags, circles, and bars. A hidden rule made one symbol more associated with dead-end corridors. Jev received cumulative outcome counts with each request—external memory, not training.

On five matched maze seeds, both Jev and fixed-order DFS solved every maze. With 80% reliable symbol clues, Jev took 608 steps to fixed DFS’s 606. At 50% noise, Jev took 518 to fixed DFS’s 606. The symbol experiment was inconclusive. In a sample this small, branch order and chance can dominate; avoiding a dead end also is not the same as moving toward the goal.

The second maze gave Jev a semantic job. The goal might be to repair a broken radio. One sign described oscilloscopes, spare transistors, and technicians. Another described a radio archive. A third described repair manuals with no tools or technicians. Jev had to interpret what the place was actually for, including exclusions, then choose a legal direction.

At 100% sign reliability, across the same five seeds:

• Jev — 194
• Seeded-random DFS — 490
• Fixed-order DFS — 606
• Keyword DFS — 736

Jev matched the shortest path in all five mazes, using 37 API calls—about 60% fewer physical steps than random DFS in this small test.

The caveat is central: this was a constructed benchmark. Full-map distances were used to place relevant descriptions along routes closer to the goal. Jev never saw those distances, the whole map, or the goal coordinate, but a correct reading of the signs reliably guided navigation at this setting. That demonstrates semantic-sign interpretation in a controlled environment, not general superiority at maze solving. The description pool was small and reused; we did not compare embeddings or another language model, or establish cost, latency, or development-time advantage.

3. Prism Memory: preserve the evidence, including uncertainty

The third experiment applied the same narrow-judgment pattern to retained meeting summaries from Prism Memory. This was a manual, optional pilot—not production retrieval.

We asked Jev to classify a source-backed candidate as an action, decision, proposal, unresolved issue, or background information. A separate check asked whether the evidence explicitly assigned responsibility to a proposed owner. That separation mattered: a proposal is not necessarily a decision, and being mentioned in a discussion is not an assignment.

The pilot covered 20 meetings and 85 candidates from an earlier retained snapshot; candidate-free summaries were skipped. A class was retained only at or above a preselected 0.90 top-class probability. An ownership relationship required both the action classification and explicit-owner check to meet that rule.

The result was 60 retained classifications, 25 abstentions, and 28 separately qualified experimental ownership relationships. The 28 relationships are not 28 additional classified candidates. Uncertain candidates kept their evidence; they were not deleted.

A small fixed review set had 11 matches in 13 classification checks and 7 in 7 ownership checks, including two deliberately wrong owner candidates. All nine reviewed classifications that crossed the threshold matched. That is a useful pilot check, not a held-out benchmark or a claim of general accuracy. The inputs were summaries, which can themselves be wrong, and a model probability is not a calibrated promise of truth.

The best result was abstention. Leaving an ambiguous item unclassified preserves the boundary between searchable evidence and an asserted organizational fact. It is better than silently turning a discussion into a decision or a mention into ownership.

The Jev pass was manually executed on a retained snapshot. It is not scheduled and does not power production search or answers.

What carried across all three?

The durable work lived outside the model: game rules, maze state, source passages, thresholds, and provenance. Jev supplied a bounded judgment where varied language or context would otherwise lead to an expanding pile of semantic rules.

That leaves an open question worth testing under messier conditions: where does this boundary still hold when summaries are noisy, categories overlap, independent labels disagree, and original transcript evidence matters? Until then, these are field notes from three experiments—not a production case study.

Public references

• Doctrine repository: https://github.com/dnellis74/doctrine
• TypeSafe primitives documentation: https://docs.typesafe.ai/primitives
• TypeSafe API documentation: https://docs.typesafe.ai/api