# A date validator can catch scheduling errors before execution

Markdown copy of https://realalpha.app/s/a-date-validator-can-catch-scheduling-errors-before/ on Real Alpha, the best minutes from long interviews with the people building AI. Cite and link the page, not this copy.

- Speaker: [Flo Crivello](https://realalpha.app/people/flo-crivello/) · Flo Crivello is founder and CEO of Lindy.
- Host: [Nathan Labenz](https://realalpha.app/people/nathan-labenz/) · Host, The Cognitive Revolution · Founded AI video company Waymark and red-teamed GPT-4 before its release.
- Show: The Cognitive Revolution
- Episode: [Lindy Teammate: Flo Crivello on Multiplayer Agents, Memory & Why He'd Ban the Chinese Models He Uses](https://realalpha.app/v/4JYoTE_VKaU/), Aug 10, 2026
- Moment: 1:21:00 to 1:27:14 of the episode (6 min), playing on https://realalpha.app/s/a-date-validator-can-catch-scheduling-errors-before/; the episode from there: https://realalpha.app/v/4JYoTE_VKaU/?t=4860

## Quote

> “we've prompted the agent to **include a weekday in the date**. So it never says July 28th.”
> — [Flo Crivello](https://realalpha.app/people/flo-crivello/) at [1:24:48](https://realalpha.app/v/4JYoTE_VKaU/?t=5088) · The Cognitive Revolution

## Takeaways

1. Validators can inspect proposed actions before they run.
2. Check weekday and date matches with a deterministic rule.
3. Keeping the same model can preserve useful cache hits.

## About this segment

Flo Crivello describes pairing agent validators with deterministic checks, including a weekday-date test for scheduling. A detailed validator prompt can also lift a model’s performance on tasks.

From “Lindy Teammate: Flo Crivello on Multiplayer Agents, Memory & Why He'd Ban the Chinese Models He Uses”, Aug 10, 2026. [Watch the full episode](https://realalpha.app/v/4JYoTE_VKaU/)

## Transcript

Transcribed by machine (Whisper) from the episode’s audio, so a word may be off here and there.

[1:21:07](https://realalpha.app/v/4JYoTE_VKaU/?t=4867) because it didn't sound easy before but in a context where you have your workflows and there's nodes in the sort of graph of work you could go into a particular node and say okay we kind of know what the inputs here are and the outputs and it's like relatively controlled environment and so we can do structured testing. You did all that and you still reported having some false positives over time where a model could pass a bunch of tests and you would feel good about it. And then if you start to test it live with users, you'd get the feedback that like, hey, like it got dumb and I'm not, you know, somehow it was like still hard to measure even with like a much more structured environment for the ai to work in now as you're in this very open-ended just tag lindy in slack and send anything um it seems like that problem would have increased in difficulty

[1:22:03](https://realalpha.app/v/4JYoTE_VKaU/?t=4923) dramatically so how are you approaching it and what are we learning in terms of where the open source models and it's not even so much i think anthropic does make some good points about this sometimes obviously there's more to the story but i do think they they're apt in some ways where they say in some cases it's less about open and close source and more about just like what's capability level what's the price what are the the features so regardless i guess of whether you're even going to open source or just going to haiku how do you decide when you can do it great question we have found you should almost never use multiple models powering the same agent and we have found one exception to this rule is when you spin up new blank sub-agents.

[1:22:43](https://realalpha.app/v/4JYoTE_VKaU/?t=4963) Emphasis on blank because there's two types of sub-agents. You have a blank sub-agent and then you have a forked sub-agent which inherits the context window of the parent agent. And the reason why you don't want to do that is because of caching. We just obsess about caching, obviously, because it's just so expensive otherwise. Like the economics do not, they barely work with caching, they just cannot work without caching.

[1:23:02](https://realalpha.app/v/4JYoTE_VKaU/?t=4982) So caching is a must-have. And so I'll give you an example. the validator system that I mentioned. So it's this LLMS judge. By the way, I highly recommend anyone who builds AI agents. This is one of the lowest hanging fruits you can do to greatly increase the reliability of your AI agent. And so that's step one, just like have a validator, which is like the naive implementation is like you ask agent to do something, it does it, or like it submits an action candidate, you intercept the action, and then you ask it, are you sure?

[1:23:30](https://realalpha.app/v/4JYoTE_VKaU/?t=5010) Literally, if it's just, are you sure? Already you get a bump on your avals, which is insane. It should not be the case, but it is the case. Now, if you increase, if you change this OU user to like an actual prompt, which in our case now is like 10,000 tokens, it's a really big validator prompt. If you change that, then you actually, you're giving it a checklist and that's got rezoning tokens. And now it's way better.

[1:23:51](https://realalpha.app/v/4JYoTE_VKaU/?t=5031) Like you can get Sonet to perform above Opus level in our experience. Now, then you can go one step further. You can have like a federation. street of validators and some of these validators may be deterministic so for example one thing we and the rest of the industry has found is that sonnet i mean cloud models this year have been getting dates wrong by one day right that's one way in which they're spiky right it's like hey you've got your ai musician it gets dates wrong it's a problem when like us you're building an ai executive assistant which half its job is to schedule meetings okay you can't get dates wrong So what we did is that we created, it's a modular architecture we have.

[1:24:33](https://realalpha.app/v/4JYoTE_VKaU/?t=5073) It's really simple. It's just like a bunch of validators and then it's like a promise.all with a timeout for people who know what this means. And so every validator has like a second to like decide what to do. And if they've not submitted their verdict, then time's out and the agent just submits the action. And we have a validator which job it is to detect dates that were submitted in the action. and we've prompted the agent to include a weekday in the date.

[1:24:59](https://realalpha.app/v/4JYoTE_VKaU/?t=5099) So it never says July 28th. It says Tuesday, July 28th. If you do that, then you can have a deterministic validator that checks whether the date of the week matches the day that was submitted. And that's just a regular expression. Instant, free, no AI in the loop. And that's one of those federated validators. But even the validators that are AI powered, you don't want, initially what we did is we were like, What if we had Sonnet for the main agent and we had like DeepSeek Flash for the sub-agent, the validator?

[1:25:29](https://realalpha.app/v/4JYoTE_VKaU/?t=5129) But actually, because when you have a cache hit, it's 10x cheaper. You actually, unless the model you're going to use is more than 10x cheaper, which it may in the case of DeepSeek Flash, it may not because the caching is inferior. You know, if that's the case, you actually don't want to keep the same model. And Sonnet is so much smarter, like it's actually worth it to just like keep the same model.

[1:25:48](https://realalpha.app/v/4JYoTE_VKaU/?t=5148) So that also holds if you fork your agent, like that way you can recycle the cache. By the way, interesting note, how do you reuse the cache when you have this validator? You know, because the problem is that changing the tool set invalidates the cache. Okay? So the way we've done it is that the validator and the agent has the validator action always included in its tool set. And it's unable to invoke it.

[1:26:12](https://realalpha.app/v/4JYoTE_VKaU/?t=5172) We tell it, don't invoke this guy unless you're the validator. And if you try, it's just like, no, I'm not going to listen to you. I'm not the validator. And then the validator now inherits all the actions of the agent. And it's like, you are now the validator. You may invoke this action, which you have known about the whole time. So that's how you don't break the cache for this kind of pattern. Yeah, and so forked agents are the same.

[1:26:34](https://realalpha.app/v/4JYoTE_VKaU/?t=5194) You just use the same model. You know, I've heard friends, founders, who've told me, I don't even want to check if it's true. I'm sure it is, which disgusts me. If you take an agent and you change the model at every turn between roughly equivalent models. So one turn, it's Sonnet. One turn is Grok 4.5 or whatever the latest is. And one turn, it's like GPT 5.6. And one turn, it actually increases the performance.

[1:26:56](https://realalpha.app/v/4JYoTE_VKaU/?t=5216) It's that ensemble. And it's literally just like a random sequence, okay? That ensemble, for some fucking reason, outperforms any given model. I don't want to know why. But apparently it works. Again, we've not even tried it because we don't want to break the cache anyway.