Video yükleniyor...
Video Yüklenemedi
I STOPPED LETTING CLAUDE MAKE DECISIONS THE DAY I BUILT THIS JEV AGENT FOLDER I used to let Claude decide, write and act on every single step -> now Claude only writes. Jev makes the calls, code does the acting, and every step leaves a receipt here's what's inside... show more
78,918 görüntüleme • 7 gün önce •via X (Twitter)
19 Yorum
@polydao i hit this wall too. once i started doing weekly reviews, my workflow tightened up a lot.
This is the first control layer I’ve seen that actually logs every decision with receipts. 10k decisions for $0.42 is the number that sticks.
This is the cleanest agent split I’ve seen: LLM only writes, Jev decides, code acts. Receipts on every call + 10k decisions for $0.42 is the part that actually matters.
What's the point of all this?
That folder makes the workflow much cleaner
right split. one gap: if misses a delete, hard_rules never sees it. gate the send/pay/delete tools themselves.
Again job mate! Let's connect
Swapping Claude's judgment for a 100ms gate might miss context. How do you handle ambiguous cases where "wake? safe? good? done?" isn't enough?
Thanks for sharing, much appreciated
i think i should copy what you did i wouldn't have even thought of this
jev is better than claude?
Jev is very interesting
The clean split is the important part. Let the model handle judgment, let code enforce the decision, and keep the expensive generation step out of the loop.
Claude writes, Jev decides, code acts. Saw this in prod: the receipts matter more than the split. My rule: a PostToolUse hook appends {step, input_hash, decided_by, exit_code} to a JSONL file Claude can't write to. If the model can edit the log, it's not a receipt.
The receipt layer is the interesting bit. Are those logs append-only, or can Jev rewrite history when a step fails?
The done check is the part most setups skip. Models agree with whoever spoke last, so asking the same model 'are we done?' gets a yes far too often. A written check it can't argue with is what actually ends the loop. The LLM should never grade its own homework.
How are the decision thresholds updated when new evaluation traces are added to the folder?
treating llms like a middle manager who overthinks every single move is the only way to scale this stuff without going broke
This decoupling architecture is elegant. Each part takes its own responsibility with clear audit trails, solves the old problem of LLM decision-making being untraceable.
![this harness stack is f*cking gold TypeSafe AI + LangChain finally dropped the layer that makes agents affordable at company scale: jev running inside the langchain agent loop as middleware the problem every big team hits: each fork in the loop is another full LLM call. at 10 agents that's a bill. at 10,000 it's the budget > routing before: every task goes to the frontier model now: jev picks the least costly model that can finish it. lookups go fast, architecture goes powerful > guardrails before: the "is this command dangerous?" check sat in the closed parts of claude code, codex, cursor now: AutoModeMiddleware(tools=["bash"]). one line, any agent, blocked before the tool runs > decisions before: one LLM call per question now: every question about the same state in one request, answered in parallel > audit before: "the model decided" now: the answer, the probability and the confidence stay in agent state > adoption no rewrite. pip install langchain-typesafe and drop it into the agent you already run TypeSafe reports up to 200x faster inference and 400x lower cost than comparable LLMs on classification. the LLM still reasons and writes. jev takes the thousands of small calls in between already live: browserbase agents for fractions of a cent, a live trading agent, email triage at scale full loop mapped below: 7 agents, 4 jev gates per step count the forks in your agent loop tonigh](https://image.24vids.com/tw-2104876056893104461/amplify_video_thumb/2104866254146203648/img/J8LnvuFvwbGYaJ7N.jpg)
![i finally mastered how to maximise my opus 5.5 usage limits... the trick: let jev choose which subagent gets each task and how much effort it should use. [here’s how i’d wire it:] claude breaks the project into tasks. jev selects from predefined worker profiles. claude applies the selected settings and dispatches the work. → main session, medium: clarify the requirements, define what “done” looks like, and prepare the tasks → builder, low: small, clearly defined tasks with existing examples or patterns → builder, medium: tasks that connect multiple parts or need decisions within the approved plan → verifier, high: check requirements, probe edge cases, and report problems for the builder to fix jev gets the task’s scope, what’s uncertain, and the consequences of failure. it chooses from the profiles allowed for that task. your approval checkpoints stay in place. paste this into your next planning session: “use opus 5.5 with jev selecting the worker and effort profile for each task. first, check that a working jev integration is available and that this environment supports separate effort settings for subagents. check for configuration or environment overrides that could prevent those settings from taking effect. if anything is missing, explain what needs wiring before proceeding. break my request into tasks with clear ownership, dependencies, relevant context, and acceptance checks. keep small related tasks together when a separate subagent would add unnecessary overhead. keep the main session at medium effort. offer jev these worker profiles: builder at low effort for small, clearly defined tasks using existing patterns; builder at medium effort for tasks that connect multiple parts or require decisions within the approved plan; verifier at high effort for checking requirements and edge cases. give jev each task’s scope, uncertainties, dependencies, and consequences of failure. only offer profiles appropriate to the current stage. validate its selection before dispatching. use the actual jev integration; don’t simulate its decisions. if it abstains or returns an invalid choice, stop that handoff and ask me. show me the task plan and proposed assignments before starting. after approval, launch the selected workers with their assigned effort settings, relevant context, file ownership, and completion checks. let me review the result before verification. the verifier may add tests but must leave implementation code unchanged. have it report what passed, what failed, and what remains uncertain. send implementation fixes back to the builder, then recheck the affected parts. if a task repeatedly fails, examine the requirements and approach before increasing effort. report available total usage, including jev calls, worker calls, retries, and verification. don’t invent missing data. compare similar completed tasks before claiming savings.” steal this 👇](https://image.24vids.com/tw-2103852115341049897/amplify_video_thumb/2103851843214614528/img/QwYdKECdjfJZgMMK.jpg)
