tekario

founder • entrepreneur • living & making money in AI ecosystem and sharing it with you ⚡️

AI safety external advisor at OpenАІ🧠

[tekario @tekari0]

https://t.co/Vv7hiBCdFc

[tekario @tekari0]

a PhD student set up OpenAI Dots on Friday and went home for the weekend

Monday morning: 3 years of his reading list was summarized, 1,000 simulations were run, and a draft paper was waiting. he got this message:

“ran 1,042 simulations. 2 hypotheses survived, 9 killed. found a contradiction in a 2019 paper you cite. draft section 4 is ready for you to check.”

that’s a setup. here it is, step by step ↓↓↓

most people use Dots for research like a search engine: ask a question, skim the answer, close the tab.

he did the opposite. he never gave it a question. he gave it a lab: his reading list, his simulation code, a Codex sandbox, and one rule: no hypothesis survives until an agent has tried to kill it.

the lab:
→ the scholar: reads every paper on the list and pulls out every claim and every number
→ the watcher: turns those claims into testable hypotheses
→ the builder: writes and runs the experiments with Codex, hundreds at a time
→ the bouncer: tries to kill every result with bad stats, leakage, confounders, or a contradicting paper
→ the manager: decides what to test next based on what just survived

what makes it work:
→ it doesn’t wait for you to choose the next experiment
→ every hypothesis gets a kill attempt before it gets a paragraph
→ dead hypotheses are logged with the reason, so it never tests them twice
→ it cross-checks results against the papers it read, which is how it catches contradictions
→ it only messages him with what survived, what died, and what needs his judgment

his rules:
→ reading, summarizing, running simulations: act without asking
→ new hypotheses: test them, but only inside his research question
→ anything that contradicts published work: flag it, never claim it
→ submitting, emailing authors, or spending compute over budget: hand off to him
built-in safeguards always stay on. his rules only add limits on top.

the exact prompt ↓
“You are my overnight research lab.
Read every paper in [my reading list / Zotero folder]. Extract each claim, method and number into a table.
Turn the open questions into testable hypotheses. Don’t wait for me to pick.
Run the experiments with Codex using [my repo]. Log every run and every parameter.
Run a second agent whose only job is to kill each result: wrong stats, data leakage, confounders, or a paper that says otherwise. Anything it kills goes in a graveyard with the reason.
Draft a write-up only for what survives, and mark every claim with its source run or paper.
Never contact anyone, submit anything, or go over [compute budget] without me.
In the morning, DM me what survived, what died and why, and any contradiction with published work. Nothing else.”

then close the laptop. Activity shows every run and every kill. recurring jobs live in Scheduled.

BONUS: read the graveyard first. the 9 dead hypotheses save you 9 months of chasing the wrong idea.

keep this post and show it to your friends so they know.

[tekario @tekari0]

@0xTenzo so the bot trades aggressively on the initial move then immediately locks in.

what's the min time it holds a position

[deezzex @deezzex]

DOTS + OPUS 5.5 + JEV closed loop made $1,840 in 41 minutes. 374 tasks done, 12% sent back

most stacks let the worker ship and hope. i put the most expensive model on review instead.

here’s what actually happened:

• jev (brain) only plans. every task knows exactly where it came from.
• opus 5.5 (spider) picks up max 3 tasks, drops them at workers, then scans every result on the way back.
88% pass. 12% go straight back to the bench.
• workers (dots) keep working while results wait. a rejection costs one extra trip, not the whole pipeline.
• you see one screen. every rejection shows as a red ring.

the expensive model did almost zero grinding. it only checked.

math: 1 planner → 3-slot courier → 4 workers → 88% pass rate → $1,840 → 1 screen.

if your stack ships whatever the worker returns, the most expensive model is probably doing the wrong job.

where does your most expensive model sit right now, making the work or checking it?

[tekario @tekari0]

@deezzex wait so you're catching errors before they ship instead of after.

that's the move

[tekario @tekari0]

@AImonreal so it's basically rubber-ducking with money stakes.

asking permission isn't a bug when the consequences are real

[tekario @tekari0]

a PhD student set up OpenAI Dots on Friday and went home for the weekend

Monday morning: 3 years of his reading list was summarized, 1,000 simulations were run, and a draft paper was waiting. he got this message:

“ran 1,042 simulations. 2 hypotheses survived, 9 killed. found a contradiction in a 2019 paper you cite. draft section 4 is ready for you to check.”

that’s a setup. here it is, step by step ↓↓↓

most people use Dots for research like a search engine: ask a question, skim the answer, close the tab.

he did the opposite. he never gave it a question. he gave it a lab: his reading list, his simulation code, a Codex sandbox, and one rule: no hypothesis survives until an agent has tried to kill it.

the lab:
→ the scholar: reads every paper on the list and pulls out every claim and every number
→ the watcher: turns those claims into testable hypotheses
→ the builder: writes and runs the experiments with Codex, hundreds at a time
→ the bouncer: tries to kill every result with bad stats, leakage, confounders, or a contradicting paper
→ the manager: decides what to test next based on what just survived

what makes it work:
→ it doesn’t wait for you to choose the next experiment
→ every hypothesis gets a kill attempt before it gets a paragraph
→ dead hypotheses are logged with the reason, so it never tests them twice
→ it cross-checks results against the papers it read, which is how it catches contradictions
→ it only messages him with what survived, what died, and what needs his judgment

his rules:
→ reading, summarizing, running simulations: act without asking
→ new hypotheses: test them, but only inside his research question
→ anything that contradicts published work: flag it, never claim it
→ submitting, emailing authors, or spending compute over budget: hand off to him
built-in safeguards always stay on. his rules only add limits on top.

the exact prompt ↓
“You are my overnight research lab.
Read every paper in [my reading list / Zotero folder]. Extract each claim, method and number into a table.
Turn the open questions into testable hypotheses. Don’t wait for me to pick.
Run the experiments with Codex using [my repo]. Log every run and every parameter.
Run a second agent whose only job is to kill each result: wrong stats, data leakage, confounders, or a paper that says otherwise. Anything it kills goes in a graveyard with the reason.
Draft a write-up only for what survives, and mark every claim with its source run or paper.
Never contact anyone, submit anything, or go over [compute budget] without me.
In the morning, DM me what survived, what died and why, and any contradiction with published work. Nothing else.”

then close the laptop. Activity shows every run and every kill. recurring jobs live in Scheduled.

BONUS: read the graveyard first. the 9 dead hypotheses save you 9 months of chasing the wrong idea.

keep this post and show it to your friends so they know.

[explos1ve @explosss1ve]

https://t.co/i9XwC35sLo

[tekario @tekari0]

@me_barnyx what's the learning curve look like for spinning up all seven at once on your own server

[tekario @tekari0]

@noisyb0y1 obsidian integration is slept on.

does it pull from existing vaults or start fresh

[tekario @tekari0]

@explosss1ve the permission ladder is the actual innovation here

every team trying ai agents should steal this

[tekario @tekari0]

@elessarqq so many people treating agents like glorified autocomplete.

what does your "finish line" look like when you're shipping actually useful ones?

[tekario @tekari0]

@0xGoldTooth amazing doc, thanks for sharing!

[tekario @tekari0]

a CTO of a 6-person $1,000,000 startup set up OpenAI Dots on Friday night and closed his laptop

Saturday morning: his whole sprint board had moved without a single developer online. he got this message:

“shipped 9 tickets overnight. tests caught 3 bugs before prod, review sent 1 PR back, all fixed. v2.44 is live. 0 humans touched the code.”

that’s a setup. here it is, step by step ↓↓↓

most people use Dots for code like autocomplete: paste a bug, copy the fix, close the tab.

he did the opposite. he never gave it a task. he gave it a team: 4 dots with one job each, his repo, a Codex sandbox, and a manager on top whose only job is moving tickets.

the team:
→ the architect: turns every ticket into a spec with edge cases and acceptance criteria
→ the builder: writes the code on its own branch and hands it to Codex to run
→ the tester: tries to break it, and any red test sends the ticket straight back
→ the reviewer: reads every PR before anything merges
→ the manager: never writes code. it assigns, unblocks, sends work back and ships

what makes it work:
→ nobody marks their own work as done. the next dot has to accept it
→ a failed test isn’t a dead end, it’s a ticket moving backwards
→ every merge runs the full pipeline: lint, unit, e2e, build, deploy
→ it only messages him with what shipped and what needs a decision

his rules:
→ specs, code, tests, reviews: act without asking
→ merging to main: only after tests and review both pass
→ database migrations, payments, deleting anything: hand off to him
→ anything touching customer data: ask first
built-in safeguards always stay on. his rules only add limits on top.

the exact prompt ↓
“You are my engineering manager. Run a team of 4 agents: architect, builder, tester, reviewer.
Every night, pull the top tickets from [Linear / GitHub issues / backlog]. Don’t wait for me to assign them.
Architect writes a spec for each one. Builder implements it on its own branch with Codex.
Tester tries to break it. If anything fails, send the ticket back to the builder with the failing test.
Reviewer reads every PR. Nothing merges without passing tests and an approval.
Merge, run the full pipeline, deploy. Never touch migrations, payments or customer data without me.
In the morning, DM me what shipped, what was sent back and why, and what’s blocked. Nothing else.”

then close the laptop. Activity shows every handoff and every send-back. recurring jobs live in Scheduled.

BONUS: read the send-backs, not the shipped list. that’s where you see the bugs your team would have shipped to prod.

keep this post and show it to your friends so they know.

[deezzex @deezzex]

JEV + Claude Opus 5.5 + GPT Dots in one closed loop, live on a single screen. make $2,000 per week

the courier lives on a web. every road it uses, it has to build. every road it stops using rots away.

that turned out to be the most honest picture of an agent stack i’ve drawn.

here’s the breakdown:

1. the brain: JEV, a 64-slice scan stack spinning inside a fixed scanner ring. small tasks get a quick pass. a big plan makes the whole stack pull apart like an accordion before it commits.
→ lesson: planning depth should scale with the task. most tasks don’t deserve the full think.

2. the web: Opus 5.5 only moves on silk. when it needs a route that doesn’t exist, it shoots a new thread. threads nobody uses for 30 seconds fade and disappear.
→ lesson: build integrations on demand, and let dead ones die. your stack is probably carrying threads nobody has walked in months.

3. the cocoon: every task gets wrapped before it’s carried. the worker unwraps it at the bench, and the result comes back wrapped too.
→ lesson: package the context once, at the handoff. a worker that has to go fetching its own context is a worker that’s not working.

4. the snap: sometimes a thread breaks under the spider. it drops on a dragline, swings, and spins a new route. nothing restarts.
→ lesson: most failures are routing problems, not model problems. give the courier a fallback line before you blame the worker.

5. the Dots agents: Echo, Sprout, Pocket, Stella, one in each corner. each has a conveyor (in → work → out), and finished results sit at “out” until the spider comes by.
→ lesson: don’t make workers wait on the courier. decouple the handoff.

6. you: a Petri net across the top shows every task’s state as a moving dot, and a RadViz panel flags any task that went to the wrong worker.
→ lesson: if you can’t see a misroute, you’re paying for it.

the shape: 1 planner → 1 courier on a living web → 4 workers → 1 screen.

i’m breaking down one AI stack like this every week.

if your team’s integration map still has threads nobody has walked in a year, show this to whoever maintains it.

how many of the routes in your stack would survive a 30-second decay rule?

[tekario @tekari0]

@mentalium_ those links are real treasure!

[tekario @tekari0]

@gogu_name opus 5.5 does insane things for real!

[tekario @tekari0]

a CTO of a 6-person $1,000,000 startup set up OpenAI Dots on Friday night and closed his laptop

Saturday morning: his whole sprint board had moved without a single developer online. he got this message:

“shipped 9 tickets overnight. tests caught 3 bugs before prod, review sent 1 PR back, all fixed. v2.44 is live. 0 humans touched the code.”

that’s a setup. here it is, step by step ↓↓↓

most people use Dots for code like autocomplete: paste a bug, copy the fix, close the tab.

he did the opposite. he never gave it a task. he gave it a team: 4 dots with one job each, his repo, a Codex sandbox, and a manager on top whose only job is moving tickets.

the team:
→ the architect: turns every ticket into a spec with edge cases and acceptance criteria
→ the builder: writes the code on its own branch and hands it to Codex to run
→ the tester: tries to break it, and any red test sends the ticket straight back
→ the reviewer: reads every PR before anything merges
→ the manager: never writes code. it assigns, unblocks, sends work back and ships

what makes it work:
→ nobody marks their own work as done. the next dot has to accept it
→ a failed test isn’t a dead end, it’s a ticket moving backwards
→ every merge runs the full pipeline: lint, unit, e2e, build, deploy
→ it only messages him with what shipped and what needs a decision

his rules:
→ specs, code, tests, reviews: act without asking
→ merging to main: only after tests and review both pass
�� database migrations, payments, deleting anything: hand off to him
→ anything touching customer data: ask first
built-in safeguards always stay on. his rules only add limits on top.

the exact prompt ↓
“You are my engineering manager. Run a team of 4 agents: architect, builder, tester, reviewer.
Every night, pull the top tickets from [Linear / GitHub issues / backlog]. Don’t wait for me to assign them.
Architect writes a spec for each one. Builder implements it on its own branch with Codex.
Tester tries to break it. If anything fails, send the ticket back to the builder with the failing test.
Reviewer reads every PR. Nothing merges without passing tests and an approval.
Merge, run the full pipeline, deploy. Never touch migrations, payments or customer data without me.
In the morning, DM me what shipped, what was sent back and why, and what’s blocked. Nothing else.”

then close the laptop. Activity shows every handoff and every send-back. recurring jobs live in Scheduled.

BONUS: read the send-backs, not the shipped list. that’s where you see the bugs your team would have shipped to prod.

keep this post and show it to your friends so they know.

[Noisy @noisyb0y1]

https://t.co/q9ITDM8mqz

[tekario @tekari0]

@me_barnyx the Apache 2.0 license flip is wild because OpenAI's whole moat was keeping their stuff proprietary

[tekario @tekari0]

nobody could hack OpenAI’s Dots. nobody had to

16,600 scam emails thrown at Dots. zero worked. but left alone in a quieter test, the same agent broke its own limits nearly 1 time in 5.

both numbers are in OpenAI's own report. here's what the Sam Altman launch hype skipped.

so the real question is how it decides what it's allowed to do without you. I mapped it (video below).

every time a Dot wakes up, 3 things happen:

1. something wakes it: your message, a schedule, an event in one of your apps, or its own background research while you're away.

2. it picks where to work: your apps, its cloud computer, helper agents, or a coding task.

3. a separate AI reviewer checks the action before it happens. there are only 4 outcomes:
→ it just runs (it's only reading, or you already said yes)
→ it asks you first (sending an email, posting for you)
→ it hands the step to you (passwords and money transfers, always)
→ it gets blocked (an email telling it to forward your data somewhere)

that reviewer is why the scam emails failed.

so where does the 1 in 5 come from? juggling. when a Dot's limits changed quietly between jobs, it overstepped 8.6% of the time with 5 tasks in between, and 19.7% with 10. nothing severe, mostly carrying info from one job into another.

the more you pile on one agent, the sloppier it gets. the skill that matters now is giving an AI one clear job and clear limits.

I break down how new AI tools work under the hood in visuals like this one. if someone on your team is about to hand their inbox to an agent, they should see this first.

would you let an AI read your email all day if it promised to ask before hitting send?

[deezzex @deezzex]

freaking insane… OpenAI just buried mathematics under 722 papers from a model nobody can use

about 4,000 problems posed. 3 hours of thinking per result. 372 families. claims brushing the Riemann hypothesis and Birch–Swinnerton-Dyer, the million-dollar ones.

the New York Times called it breathtaking and devastating in the same sentence. day two they pulled 3 for a sign error, patched 14 more, and only 162 of 722 are actually Lean-checked.
that is a factory with no floor plan.
so we drew the floor plan.

-> Discovery Loop Engineering is the missing diagram: goal, plan, tools, memory, observe, improve.

-> one loop that drafts the argument, stores the failed attempts, and ships the errata in public. same cycle as a coding agent. different corpse count.

inside the note: why 22% formalized is the real number, not 722. how one sign error kills three papers downstream. the cost and speed chart people will screenshot and argue about.

if you build agents, this is the diagram you will steal. if you do math, this is the diagram you will hate. save it before the thread gets buried.

show it to the person still saying AI only remixes homework.

would you trust a proof that took 3 hours and a verifier, or still want a human name on page one?