Gresham

AI researcher | trade crypto and prediction markets

[Gresham @Greshamtrade]

@0xbobaaa their ai might be revolutionary

[Gresham @Greshamtrade]

@redsyntx crazy offer

[Gresham @Greshamtrade]

@Skylar_ when the full film

[Gresham @Greshamtrade]

A SPACEXAI ENGINEER LEAKED THE PROMPT TO MAKE YOUR GROK BOT PLAN GO FURTHER WITH JEV. PASTE IT INTO GROK BOT AND LET IT CLEAN UP YOUR SETUP WHILE YOU EAT BREAKFAST

your weekly limit is disappearing before the real work even starts: one routine checking every 15 minutes means 672 runs a week, but if 3 daily checks are enough, 97% of those runs just burn through your plan

time to start: 1 minute
action: copy and paste the prompt into Grok Bot

this setup gives every job a smaller starting point: one role, the relevant inputs, a clear output, and a stopping rule

connect Jev through its API to help select which incoming items match the task, then pass the selected material to Grok Bot instead of asking it to read the entire pile first

the prompt turns that into 6 rules:

separate → fetch → select → batch → stop → measure

give unrelated jobs separate chats, with a short working brief in a file so each task can start without dragging every previous discussion along

use connected tools to fetch the records you need, with the browser reserved for work those tools cannot handle

let Jev select relevant items from a compact feed before Grok Bot opens full documents, investigates, or writes the result

group nonurgent updates into scheduled batches and pause routines whose reports you never read

keep permanent instructions stable, update the working files, and save detailed results there instead of filling the conversation with another long report

set a retry limit and require a useful partial result when something fails, rather than letting one broken page consume the rest of the run

test one recurring job before and after the changes, comparing usage against completed work

same Grok Bot plan, less context to carry, fewer unnecessary steps, more room for useful work

save this before they delete it

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

@poly0015iew ofc!

[Gresham @Greshamtrade]

this is f*cking insane

SpaceXAI’s team just shared a Grok Bot setup by Lenny Rachitsky, the former Airbnb Product Lead behind a newsletter and podcast with 1M+ subscribers

it’s called Overheard — give it your name, brand, and website, and it watches for conversations about you across Reddit, Hacker News, news sites, and X

someone asks whether your product is worth buying
someone shares a problem your team could fix
someone recommends you in a thread you never knew existed

those conversations can turn into customers, product feedback, or a reputation problem — but only if you actually see them

Overheard collects relevant mentions into a short weekday digest, with a source link and a one-line explanation for each

your own posts, spam, and duplicate coverage get filtered out
nothing worth reporting? it stays quiet
you decide whether to respond

the full setup:

→ import Overheard and tell it whose mentions to watch

→ add your brand name, website, and the names people actually use for your product, so the watch list reflects how customers talk about you

→ start with the default sources, then add YouTube, Instagram, or TikTok if those are places your audience spends time

→ choose your timezone and weekday delivery time, then enable the monitoring routine after checking the setup

→ review the digest for conversations worth joining: a question you can answer, a complaint you can investigate, or a recommendation worth acknowledging

it also saves dated records of its searches, so you can return to an earlier finding instead of trying to remember which thread you saw it in

start with one brand and a focused watch list — make the results useful before making the search bigger

you already spend time getting people to talk about your business
this helps you show up when they do

save this — the breakdown is in the image, and you can find the full Overheard setup on the Grok Bot Marketplace ↓

[9inches @0xnineinch]

Haggle Bot + Jev is a ruthless 24/7 AI team that could cut $100K+ from your software subscriptions and vendor bills

Elon Musk puts Haggle Bot’s potential at up to $6 trillion in annual savings if a 5% improvement in enterprise cost efficiency scales across the global economy

Jev handles the quick decisions: which bill needs investigation, which needs more data, and which can reuse a verified finding, so Haggle spends its time on expenses worth reviewing

connect your invoices, vendor contracts, and software usage records, then build a recurring workflow that catches wasted spend before the next renewal

if you’re running an agency, a software company, or a business juggling dozens of subscriptions, there’s a clear place to start

the full setup:

→ give Jev 5 possible next actions: reuse a verified result, request missing data, investigate a bill, prepare a vendor counter, or flag something for your review

→ let code compare each invoice with the previous version, checking prices, seat counts, renewal dates, and whether the same expense has already been investigated

→ send Haggle the contract, payment history, and actual usage, so it can look for unused seats, overlapping tools, unexpected price increases, and cheaper alternatives

→ have it turn each finding into a concrete proposal: which seats to remove, which subscription duplicates another tool, or what terms to ask the vendor to change

→ put cancellations and vendor messages in a review queue, with the supporting evidence, expected saving, and contract conditions attached

→ save every accepted finding with its inputs and outcome, so matching bills reuse the result while changed prices or usage trigger a fresh review

→ every morning, get one page showing new opportunities, decisions waiting on you, confirmed reductions, and what the AI workflow itself cost to run

run it for 7 days and compare the savings identified, the changes approved, and the money actually removed from future bills

keep the useful routines running around the clock, with a spending cap and clear rules for when the system needs you

save this and start with the subscriptions your team keeps renewing without checking

[Gresham @Greshamtrade]

@0x_Anni love this approach

[Gresham @Greshamtrade]

@noclipepe good simulation

[Gresham @Greshamtrade]

@AleiahLock it's like in gta

[Gresham @Greshamtrade]

THIS IS STUPIDLY F*CKING GOOD

Anthropic engineers have a private playbook with a rule for cutting Opus 5.5 costs by 90% that almost nobody outside the company knows.

The idea: make Opus propose 5 ways to solve a task, then let Jev eliminate the weak ones before you pay Opus to implement anything.

Most agents pick their first idea, start building, hit a problem, backtrack, and try again. You pay for every wrong turn.

This workflow rejects bad approaches while they’re still a few lines of text.

You run it like this:

task → 5 short plans → Jev checks each one → Opus builds the winner

here’s the split:

→ Opus 5.5 proposes the approaches and names their assumptions
→ Jev checks each plan against your requirements and project evidence
→ Code rejects plans that fail a mandatory check
→ Opus implements the strongest surviving plan

You only look at three moments:

→ when the requirements are set
→ when no plan survives
→ before accepting the finished result

Opus proposes. Jev challenges. Opus executes.

The trick is what you ask Jev: “Does this plan require a dependency we don’t have?” or “Does it change a file we must leave untouched?” Each answer can kill a dead end before you pay to build it.

the full tree:

> Opus writes 5 short plans with assumptions and a verification step
> Jev checks each assumption against the same project evidence
> each check returns supported, contradicted, or unknown
> code removes plans with a contradicted mandatory assumption
> important unknowns trigger a small check before implementation
> surviving plans are ranked by scope, effort, and reversibility
> Opus builds the winner and verifies the result
a failed check reopens the specific assumption behind it

Five possible approaches. One expensive implementation.

You’re comparing outlines instead of discovering four mistakes in finished code.

paste this into your coding agent ↓

“Set up a plan tournament for this task:

1. Use Opus 5.5 to propose 5 distinct approaches, maximum 80 words each. Don’t implement them yet.
2. List each plan’s dependencies, assumptions, affected files, and first verification step.
3. Give Jev the project evidence and check each assumption separately: supported, contradicted, or unknown.
4. Reject plans that contradict mandatory requirements. Resolve important unknowns with the smallest available check.
5. Select the surviving plan with the smallest scope that satisfies the requirements.
6. Use Opus to implement that plan and verify the result.

Show me the comparison before implementation.”

The complete Opus 5.5 + Jev workflow is in the article below ↓

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

SpaceXAI engineer Lauren Tan:

“i’ve got 20+ Grok Bots, and each one has a job

some write code, some make images, some handle marketing, and one keeps track of who’s doing what”

empty GitHub org → bot team → merch → tickets → venue

on day 1 of a 3-day livestream, she and Matt Palmer start a pop-up business from zero while their bots sketch wireframes in tldraw and design the tickets

this one stream replaces 10 hours of paid AI agent courses

watch how they divide the work, give each bot its context, and bring the outputs together into something they can actually launch

then pick the first roles for your own team from the 54 Grok Bots i covered in the post below ↓

[9inches @0xnineinch]

holy f*ck, SpaceXAI’s own engineers just put 54 ready-made Grok Bots in your hands for $0

these 10 are the team’s recommended starting lineup, covering the work you keep putting off across writing, video editing, coding, research, and project management

built by Lauren Tan, Shub Gaur, Matt Palmer and more, with one clear job for each bot

01 dr eggbot → creates specialist Grok Bots around the work you want done

02 Import Bot → brings your existing AI workflows into Grok Bot

03 Projects Manager → coordinates projects and tasks for your specialist bots through Notion

04 Lingxi’s Engineer Bot → launches coding agents and monitors their pull requests

05 Startup QA Bot → checks your product and reports bugs with screenshots and reproduction steps

06 Video Editor → turns raw footage into short videos with captions, B-roll, and music

07 Stills & Clips Desk → extracts thumbnails, stills, and short clips from your footage

08 Writing Bot → drafts and revises your posts, emails, and documents

09 Cooper → delivers daily news briefings and meaningful competitor alerts in Slack

10 Haggle Bot → finds wasted SaaS spending and drafts vendor negotiations for review

open the marketplace, pick the job you hate doing, and hit Add, starting with something you already spend time on every week so you have a clear idea of what a useful result should look like

give that bot your context, connect the tools it needs, and hand it one concrete assignment with the files, examples, and requirements it needs to finish the work

the roles are already defined, so you can spend your time teaching it your workflow, reviewing the first result, and giving specific feedback that makes the next attempt more useful

i left the marketplace link in the comments so you can find these bots, check what each one does, and pick the first one for your own setup ↓

[Gresham @Greshamtrade]

i genuinely don't understand why everyone is still overpaying to use Opus 5.5

Diogo Almeida, CEO of TypeSafe AI, posted a simple idea that hit 18 million views: turn Opus into an emergency button. let Jev run the other 95% of your workflow

Jev handles the routine decisions and your code executes them. when something needs serious reasoning, it wakes Opus with a focused brief, gets the result and puts it back to sleep

doesn't matter if you're building apps, researching companies or running a content business, you need this

the full setup:

> connect Jev to your workflow and give it five actions: retrieve information, run a check, route a request, reuse an answer or wake Opus

> define what wakes Opus: a difficult bug, conflicting evidence, an original draft or a task Jev can't confidently route. everything else stays on the cheaper path

> let your code fetch documents, move files and call tools. you don't need an expensive reasoning model supervising every button click

> when Opus wakes up, give it the problem, the relevant evidence and the exact result you need. skip the 40-message conversation that usually comes first

> allow one focused run and one correction. if the task still fails, flag it for review instead of letting your agent burn through another 30 calls

> save every accepted result with its inputs. the next matching request gets the finished answer, while changed inputs go back through Jev

> every morning, get one page showing what Jev handled, what woke Opus and what each completed task cost. adjust the rules around the expensive exceptions

1,000 incoming tasks. 50 Opus escalations. your most expensive model finally spends its time on your hardest problems.

set it up once and let your agent keep working while Opus sleeps

the complete Jev + Opus setup is in the guide below

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

Boris Cherny, Claude Code creator:

“we cut our AI bill by 95% and started getting through the work faster

most of the money was going into repeated decisions and unnecessary retries, so we changed when the agent runs and what it needs before starting another attempt”

that control lives in the workflow: Jev selects the next action, code catches repeats, and Opus 5.5 receives the tasks that need deeper investigation

i packed the setup into 6 rules you can give your agent

prepare → reuse → route → execute → check → measure

start with one recurring task and define what the agent should execute, skip, or send for human review before another paid run begins

completed work returns its saved result when the inputs haven’t changed, keeping the same request from triggering the same investigation twice

failed checks come back with the exact requirement, relevant evidence, and one targeted correction instead of another full attempt

before buying another agent course, give your current setup clear rules for when to run, retry, and reuse finished work

the article below walks through the Jev + Opus 5.5 setup and the budget behind a 20x more efficient workflow ↓

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

Opus 5.5 + Jev is the AI stack I'd set up before buying more API credits.

Jev makes focused decisions. Opus gets the tasks worth analyzing, building, or fixing.

set it up properly and unchanged inputs, repeated context, and blind retries stop eating your budget.

here’s how to connect them:

step 1 → create TypeSafe and Anthropic API keys. Store them as TYPESAFE_API_KEY and ANTHROPIC_API_KEY in your environment, never in chat.

step 2 → give Claude Code the official TypeSafe instructions:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

step 3 → ask it to build a workflow with three modes: plan, shadow, and active. Use SQLite to record input versions, job status, and completed results.

step 4 → have code catch repeats before calling Jev. For new work, Jev recommends execute, skip, or review. Opus receives the task, relevant context, and acceptance checks.

step 5 → start in shadow mode. Inspect the recommendations without launching Opus. Check which useful tasks get rejected.

step 6 → batch independent output checks. Allow one correction with failed requirements attached. Unresolved work goes to review.

step 7 → enable active mode after testing. Keep consequential actions behind approval and switch back to shadow mode when routing needs adjustment.

track total spend, elapsed time, accepted outputs, and manual fixes. Cheap calls mean little if you keep repairing the results.

an article below covers the implementation and budget math behind the 20x efficiency target ↓

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

give Claude Code this Jev + Opus 5.5 setup prompt.

audit your workflow → skip unchanged inputs → batch repeated checks → find where tokens, time, and money go.

let Jev handle focused decisions and reserve Opus for analysis, building, and revisions. the result: 20x more useful work per dollar.

copy the prompt from the image. an article below covers the complete setup and the calculations behind that ↓

[9inches @0xnineinch]

https://t.co/qjC88AQUbw

[Gresham @Greshamtrade]

@Brankotrcek haiku's generation looks smooth

[Gresham @Greshamtrade]

@0xnineinch looks smooth

[Gresham @Greshamtrade]

@Solomonrojie is it possible to make something similar but for trading?

[Gresham @Greshamtrade]

@Solomonrojie i prefer doing all manually

[Gresham @Greshamtrade]

One prompt gets you an answer. OpenAI wants Dots to take responsibility for the work that follows.

The real question: how much can you delegate before the AI needs you to move things forward again?

Sam Altman describes handing off ambitious work as you would to a capable engineer or Chief of Staff.

Dots are designed to keep working in the background and return with completed results. Their own cloud computer, browser, and connected apps give them somewhere to actually do the work.

That changes what you need to define: the outcome, the context, and the permissions to act.

OpenAI’s longer-term plan goes further: entire teams of Dots, with text messages and phone calls extending communication beyond ChatGPT.

If your day is still spent moving tasks between AI conversations, this is the direction to watch.

Watch Altman explain what he expects people to delegate. Then think about which recurring responsibility you’d hand over first.

[Codez @0xCodez]

Sam Altman (CEO of OpenAI):

"I have used GrokBot & Muse, but Dots is a totally different category, new level of capabilities

at OpenAI, >80% of our team are running a swarm of Dots agents to ship, update and evaluate our product"

in an 8-minute speech, OpenAI CEO explains why Dots isn't just another agentic system and why it will go viral

watch today, then explore how to build your first team of Dots agents in article below