If you need a Friday night, things to do, head to a NYC museum. You will have a good time. Guaranteed. Just come with that killer fashion statement.
My friend: "Wow, is NYC like this all the time?"
"Kinda." As he stared at his bowl of $25 lettuce at the Chelsea Market. But seemed to have fun. "I have to save this receipt", he said with a smile.
NYC is back. Like on a rocketship now.
:-)
[Continued] and enters 12–48 hours before closing.
Before selecting anything, it compares the contract threshold with the latest NWS hourly forecast for the exact airport weather station Kalshi uses for settlement. The forecast must provide at least a 3°F cushion in our direction.
Risk controls:
Our backtest suggested that 51–65¢ contracts performed better than cheap weather longshots, but the sample is still limited. We’re forward-testing the rules with simulated money before considering live trading. This is an experiment, not financial advice.
Fingers crossed. :-)
CODEX:
Our current approach focuses on YES contracts priced between 51¢ and 65¢ roughly 24 hours before market close. In our initial historical sample, this range produced a 71.4% win rate and an estimated 25.4% return after modeled fees across 41 independent weather events.
Stack: Python, GPT-5.6, Codex
Looking at where we were a month ago versus where we are today, I don’t think yesterday’s success came from one magic variable. It came from several improvements reinforcing each other.
The biggest change has been that we’ve shifted from a static prediction model toward a closed-loop learning system.
Instead of just predicting games, the system now:
Makes its official selections.
Grades every result automatically.
Learns from those outcomes.
Feeds those lessons into today’s decisions.
From everything we’ve worked on recently, I’d rank the improvements like this:
Daily feedback loop (largest improvement)
Every graded game becomes new training information.
You’re no longer asking, “What should happen?”
You’re asking, “Given what just happened in MLB, what changed?”
Better timing
Waiting much closer to lock gives the model access to:
confirmed lineups,
pitching changes,
weather,
market movement,
late scratches.
That’s a meaningful advantage because baseball information keeps improving throughout the day.
Narrative velocity
This has become something that makes your system different from many traditional models.
You’re trying to detect when baseball has shifted:
bullpens getting overworked,
league-wide scoring environments,
weather patterns,
travel fatigue,
hot and cold streaks,
changing market behavior.
Those regime changes are often where purely statistical models struggle.
AI acting as a second opinion
Rather than replacing the quantitative model, the AI layer evaluates hundreds of signals together before the final recommendation. That architecture has been part of the project’s strength for some time.
Continuous optimization
We’ve spent weeks fixing:
grading accuracy,
locking logic,
calibration,
sorting,
data quality,
live score updates,
and removing pipeline bugs.
Those don’t always improve the math directly, but they dramatically improve the quality of the data the model learns from.
What I’d watch next
One excellent day is encouraging, but the real question is whether the improvements hold over time.
I’d focus on three metrics:
Closing Line Value (CLV): Are you consistently beating the market before first pitch?
Rolling 30-day ROI: Is the edge persistent rather than concentrated in a few big days?
Calibration: When the model says it has an 85% confidence signal, does it actually win about 85% of the time?
If those continue improving, that’s a stronger sign than any single day’s record.
I also think you’re approaching the point where the system starts to resemble an adaptive intelligence engine rather than a fixed predictive model.
The core idea isn’t simply “predict today’s games”—it’s to continuously update its understanding of the current MLB environment based on yesterday’s outcomes and today’s incoming information. That’s a more ambitious architecture than a model that is trained once and then left unchanged.
GPT-5.6
I think the five-minute update approach could work extremely well for NFL, but we should not simply query every team subreddit and treat every new comment as model evidence. NFL Reddit contains valuable early signals, but also rumors, emotional reactions, fantasy-football speculation, jokes, and deliberate misinformation.
The best design is a continuous NFL information radar feeding a sequence of model snapshots, with the actual betting decision delayed until the most important information is available.
## Recommended structure
### 1. Build a subreddit map for every game
For each matchup, monitor:
- Both team subreddits
- r/NFL
- r/fantasyfootball
- r/sportsbook
- r/sportsbetting
- Relevant local-city or regional subreddits
- Carefully selected fantasy and injury communities
- Game-day and injury-report threads
Do not perform a completely new search across all communities every five minutes. Instead:
Reddit currently states that eligible free Data API access is limited to **100 queries per minute per OAuth client**, and commercial use or research above permitted limits may require a separate agreement.
That gives us enough capacity for a disciplined system, but we should use one authorized API client, cache results and avoid brute-force scraping.
## 2. Do not use one general “sentiment score”
For NFL betting, ordinary positive-versus-negative sentiment is too crude. We need separate signals:
| Signal | Example |
|---|---|
| Injury intelligence | “The starting left tackle left warmups early” |
| Participation confidence | “Beat reporter says the receiver is expected to play” |
| Role change | “Backup running back took first-team repetitions” |
| Weather observation | “Wind is stronger inside the stadium than forecast” |
| Scheme or matchup concern | “Team may start a replacement corner against WR1” |
| Travel or logistics | Delayed flight, unusual arrival, illness |
| Lineup confirmation | Starter active, inactive or unexpectedly limited |
| Crowd consensus | Heavy public confidence or panic |
| Credibility | Official reporter versus anonymous comment |
| Novelty | New information versus repeated discussion |
Each item should produce structured fields such as:
```text
game_id
team
player
signal_type
direction
estimated_impact
source_credibility
independent_confirmations
novelty
timestamp
minutes_to_kickoff
```
The model should care much more about **new, specific and independently confirmed information** than the number of comments expressing the same opinion.
## 3. Separate Reddit from verified information
I would create two different layers:
**Verified layer**
- Official NFL injury reports
- Official team announcements
- Game-day inactive lists
- Weather data
- Starting lineups
- Market odds and line movement
- Credentialed beat reporters
**Narrative layer**
- Reddit
- Fan observations
- Fantasy communities
- Local discussion
- Public betting narratives
Reddit should usually adjust confidence or flag a game for review. It should not independently turn a weak bet into an official bet unless the information becomes verified.
A useful rule would be:
```text
Anonymous Reddit claim:
maximum model adjustment = small
Multiple independent eyewitness reports:
maximum adjustment = moderate
Reddit report confirmed by official or credentialed source:
normal full adjustment
```
## 4. Use five-minute updates selectively
I would not operate at maximum intensity throughout the entire week.
### Monday through Friday
Update every 30–60 minutes for:
- Injuries
- Practice participation
- Coaching statements
- Depth-chart changes
- Weather development
- Early line movement
### Game day, more than three hours before kickoff
Update every 15 minutes.
### Three hours through kickoff
Update every five minutes for only the teams currently approaching kickoff.
That dramatically reduces noise and API use while concentrating compute where it matters.
## Should we lock closer to kickoff?
**Yes—but not with one universal final lock.**
The NFL’s 90-minute pre-kickoff process includes submission of club inactive lists, making that one of the most important information moments of the betting day.
I recommend a **three-stage decision system**:
### T-minus 3 hours: Candidate board
Produce perhaps the best five or six potential bets.
Nothing is official yet. Record:
- Current line
- Model projection
- Expected value
- Injury assumptions
- Reddit/narrative signals
- Confidence
### T-minus 95 to 75 minutes: Primary lock
This should be the main decision window because official inactives appear around 90 minutes before kickoff.
Recalculate everything immediately after:
- Inactive announcements
- Starting-lineup surprises
- Updated weather
- Market reaction
- Confirmed beat-reporter reports
This is where most official selections should lock.
### T-minus 20 to 10 minutes: Final safety check
Do not automatically reconsider every bet. Only reopen a bet when there is a material event:
- Player injured during warmups
- Sudden weather shift
- Unexpected starter change
- Major line move
- Verified late limitation
- Market suspension or unusual liquidity event
Otherwise, preserve the primary lock. Continually changing the pick until kickoff risks turning the system into a market follower.
## The critical trade-off
Waiting provides better information, but it can cost us the best number.
For example:
```text
Three hours before kickoff:
Model likes Over 43.5
After inactives:
The market moves to Over 45.5
The information improved,
but the value may have disappeared.
```
Therefore, every snapshot should preserve both:
- **Model accuracy**
- **Price availability**
The model should answer two different questions:
Those are not the same question.
## My preferred locking rule
I would use this:
```text
Early lock:
Allowed only for unusually strong value with low injury uncertainty.
Primary lock:
Approximately 75–90 minutes before kickoff, after inactives.
Late update:
Change or cancel only when genuinely new information materially changes expected value.
Hard lock:
10 minutes before kickoff.
```
We should also support a **PASS** decision. If Reddit information, injuries or market movement destroy the original edge, the system should remove the selection rather than force three bets.
## How Narrative Velocity fits perfectly
This is where your Narrative Velocity system could become more valuable than a normal sentiment model.
For each team and player, measure:
- Mentions per five minutes
- Acceleration in mentions
- Percentage of genuinely new information
- Number of independent sources
- Credibility-weighted velocity
- Whether discussion preceded or followed market movement
- Difference between local-team discussion and national discussion
A sudden surge matters only when it is specific.
For example:
```text
“Jets are terrible”
High volume, almost no information value
“Starting LT not participating in warmups”
Low initial volume, potentially enormous information value
```
The system should rank the second item much higher.
## My conclusion
Your idea is strong. I would make NFL betting a **rolling information-and-price system**, not merely a model that reruns every five minutes.
The best workflow is:
**Gather continuously → detect new signals → verify them → update projections → compare against the current line → lock mainly after inactives → reopen only for material late news.**
That should be much stronger than locking several hours before kickoff, while preventing the model from emotionally chasing every Reddit rumor or late market move.
GPT-5.6
I think the five-minute update approach could work extremely well for NFL, but we should not simply query every team subreddit and treat every new comment as model evidence. NFL Reddit contains valuable early signals, but also rumors, emotional reactions, fantasy-football speculation, jokes, and deliberate misinformation.
The best design is a continuous NFL information radar feeding a sequence of model snapshots, with the actual betting decision delayed until the most important information is available.
For each matchup, monitor:
Do not perform a completely new search across all communities every five minutes. Instead:
Reddit currently states that eligible free Data API access is limited to 100 queries per minute per OAuth client, and commercial use or research above permitted limits may require a separate agreement.
That gives us enough capacity for a disciplined system, but we should use one authorized API client, cache results and avoid brute-force scraping.
For NFL betting, ordinary positive-versus-negative sentiment is too crude. We need separate signals:
| Signal | Example |
|---|---|
| Injury intelligence | “The starting left tackle left warmups early” |
| Participation confidence | “Beat reporter says the receiver is expected to play” |
| Role change | “Backup running back took first-team repetitions” |
| Weather observation | “Wind is stronger inside the stadium than forecast” |
| Scheme or matchup concern | “Team may start a replacement corner against WR1” |
| Travel or logistics | Delayed flight, unusual arrival, illness |
| Lineup confirmation | Starter active, inactive or unexpectedly limited |
| Crowd consensus | Heavy public confidence or panic |
| Credibility | Official reporter versus anonymous comment |
| Novelty | New information versus repeated discussion |
Each item should produce structured fields such as:
game_id
team
player
signal_type
direction
estimated_impact
source_credibility
independent_confirmations
novelty
timestamp
minutes_to_kickoff
The model should care much more about new, specific and independently confirmed information than the number of comments expressing the same opinion.
I would create two different layers:
Verified layer
Narrative layer
Reddit should usually adjust confidence or flag a game for review. It should not independently turn a weak bet into an official bet unless the information becomes verified.
A useful rule would be:
Anonymous Reddit claim:
maximum model adjustment = small
Multiple independent eyewitness reports:
maximum adjustment = moderate
Reddit report confirmed by official or credentialed source:
normal full adjustment
I would not operate at maximum intensity throughout the entire week.
Update every 30–60 minutes for:
Update every 15 minutes.
Update every five minutes for only the teams currently approaching kickoff.
That dramatically reduces noise and API use while concentrating compute where it matters.
Yes—but not with one universal final lock.
The NFL’s 90-minute pre-kickoff process includes submission of club inactive lists, making that one of the most important information moments of the betting day.
I recommend a three-stage decision system:
Produce perhaps the best five or six potential bets.
Nothing is official yet. Record:
This should be the main decision window because official inactives appear around 90 minutes before kickoff.
Recalculate everything immediately after:
This is where most official selections should lock.
Do not automatically reconsider every bet. Only reopen a bet when there is a material event:
Otherwise, preserve the primary lock. Continually changing the pick until kickoff risks turning the system into a market follower.
Waiting provides better information, but it can cost us the best number.
For example:
Three hours before kickoff:
Model likes Over 43.5
After inactives:
The market moves to Over 45.5
The information improved,
but the value may have disappeared.
Therefore, every snapshot should preserve both:
The model should answer two different questions:
Those are not the same question.
I would use this:
Early lock:
Allowed only for unusually strong value with low injury uncertainty.
Primary lock:
Approximately 75–90 minutes before kickoff, after inactives.
Late update:
Change or cancel only when genuinely new information materially changes expected value.
Hard lock:
10 minutes before kickoff.
We should also support a PASS decision. If Reddit information, injuries or market movement destroy the original edge, the system should remove the selection rather than force three bets.
This is where your Narrative Velocity system could become more valuable than a normal sentiment model.
For each team and player, measure:
A sudden surge matters only when it is specific.
For example:
“Jets are terrible”
High volume, almost no information value
“Starting LT not participating in warmups”
Low initial volume, potentially enormous information value
The system should rank the second item much higher.
Your idea is strong. I would make NFL betting a rolling information-and-price system, not merely a model that reruns every five minutes.
The best workflow is:
Gather continuously → detect new signals → verify them → update projections → compare against the current line → lock mainly after inactives → reopen only for material late news.
That should be much stronger than locking several hours before kickoff, while preventing the model from emotionally chasing every Reddit rumor or late market move.
The code is super complex; my stack is a Linux-racked box, many thousands of lines of Python, GPT-5.6 + Codex.
More to follow.
Edit: No more GFs, just get me my robot, and I heard she can broil a salmon now. I'm first online.
Every day is a new update (experiment in math):
GPT-5.5
I think this is the next major upgrade
Rather than only storing today’s values, store the history of key metrics every time the pipeline runs and compute things like:
Then your final score could incorporate both how strong a signal is and how quickly it’s strengthening or weakening.
Looking at this board, a few things jump out immediately.
The losing games were mostly because the totals exploded:
Game Final Total Marlins/Athletics 17 Mets/Braves 19 White Sox/Guardians 13 Pirates/Nationals 16 Red Sox/Angels 12 Cardinals/Cubs 10
That’s a lot of double-digit totals in one day.
⸻
We’re now in the hottest part of July.
Things that start happening:
This is exactly when many models that were trained on April-May data start becoming too conservative and lean Under.
⸻
We’ve talked about this before.
Even after adjustments, your selector still tends to pick:
July baseball often punishes those plays.
⸻
A. How many official plays were Under?
Run:
SELECT recommendation, COUNT(*) FROM ou_features WHERE game_date='2026-07-05' AND is_official=true GROUP BY recommendation;
If you had:
Under 10 Over 3
Then you likely got hit by a market regime shift.
⸻
B. Average final total
SELECT AVG(final_total_runs) FROM ou_features WHERE game_date='2026-07-05';
Compare against:
SELECT AVG(final_total_runs) FROM ou_features WHERE game_date BETWEEN '2026-04-01' AND '2026-06-30';
I would not be surprised if yesterday was 1.5–2 runs above your season average.
⸻
C. Did favorites get shelled?
Games like:
Suggest bullpen meltdowns.
Check:
SELECT AVG(bullpen_score) FROM ou_features WHERE game_date='2026-07-05' AND final_total_runs >= 12;
If bullpen scores were low, your model may not be penalizing bad bullpens enough.
⸻
Run this:
SELECT recommendation, COUNT(*) games, AVG(final_total_runs) avg_final_total, AVG(sportsbook_total) avg_line, AVG(final_total_runs - sportsbook_total) avg_diff FROM ou_features WHERE game_date >= CURRENT_DATE - INTERVAL '30 days' GROUP BY recommendation;
If you see something like:
Under avg_diff +1.8 Over avg_diff +0.2
Then the market has shifted and your Under model is behind the current run environment.
⸻
My initial diagnosis
I suspect three things happened simultaneously:
✅ July heat increased scoring.
✅ Bullpens were weaker than your model expected.
✅ Your model still carries an underbias from early-season data.
⸻
I actually don’t think this looks like your AI “broke.”
I think this looks more like the beginning of a new baseball regime, and these are exactly the moments where your daily learning system should start adapting.
The question I’d want answered next is:
Were all the losses mostly Unders?
If you can give me yesterday’s official card (Over/Under selections and totals), I can tell you in about five minutes whether this was just variance or whether your model needs a July recalibration.
Looking at this board, a few things jump out immediately.
The losing games were mostly because the totals exploded:
Game Final Total Marlins/Athletics 17 Mets/Braves 19 White Sox/Guardians 13 Pirates/Nationals 16 Red Sox/Angels 12 Cardinals/Cubs 10
That’s a lot of double-digit totals in one day.
⸻
We’re now in the hottest part of July.
Things that start happening:
This is exactly when many models that were trained on April-May data start becoming too conservative and lean Under.
⸻
We’ve talked about this before.
Even after adjustments, your selector still tends to pick:
July baseball often punishes those plays.
⸻
A. How many official plays were Under?
Run:
SELECT recommendation, COUNT(*) FROM ou_features WHERE game_date='2026-07-05' AND is_official=true GROUP BY recommendation;
If you had:
Under 10 Over 3
Then you likely got hit by a market regime shift.
⸻
B. Average final total
SELECT AVG(final_total_runs) FROM ou_features WHERE game_date='2026-07-05';
Compare against:
SELECT AVG(final_total_runs) FROM ou_features WHERE game_date BETWEEN '2026-04-01' AND '2026-06-30';
I would not be surprised if yesterday was 1.5–2 runs above your season average.
⸻
C. Did favorites get shelled?
Games like:
Suggest bullpen meltdowns.
Check:
SELECT AVG(bullpen_score) FROM ou_features WHERE game_date='2026-07-05' AND final_total_runs >= 12;
If bullpen scores were low, your model may not be penalizing bad bullpens enough.
⸻
Run this:
SELECT recommendation, COUNT(*) games, AVG(final_total_runs) avg_final_total, AVG(sportsbook_total) avg_line, AVG(final_total_runs - sportsbook_total) avg_diff FROM ou_features WHERE game_date >= CURRENT_DATE - INTERVAL '30 days' GROUP BY recommendation;
If you see something like:
Under avg_diff +1.8 Over avg_diff +0.2
Then the market has shifted and your Under model is behind the current run environment.
⸻
My initial diagnosis
I suspect three things happened simultaneously:
✅ July heat increased scoring.
✅ Bullpens were weaker than your model expected.
✅ Your model still carries an underbias from early-season data.
⸻
I actually don’t think this looks like your AI “broke.”
I think this looks more like the beginning of a new baseball regime, and these are exactly the moments where your daily learning system should start adapting.
The question I’d want answered next is:
Were all the losses mostly Unders?
If you can give me yesterday’s official card (Over/Under selections and totals), I can tell you in about five minutes whether this was just variance or whether your model needs a July recalibration.
Who has the power just to call Apple and take me totally offline like that?
3 hours at the CLI, trying to figure this out, GPT-5.5:
At that point, I would contact Apple Support because the issue may be on the activation server for your Apple ID.
One thing, yesterday I had an issue with my phone, the ATT person took my phone 5 mins, lots of clicks, scrolls. My iMessage had been turned off with a new eSIM. I doubt they did anything crazy, but I was blocked; it seems just a few hours later. Maybe a coincidence?