Sherif Zaidan

Robotics PhD, Founder, CTO / One Exit + 4 failures / Chief Product Aramco Digital / views my own

[Hesham Ghandour @heshamghandour]

The best idea in your company belongs to someone who can't ship it.

Flamin' Hot Cheetos was invented by a janitor. He didn't wait for permission. He just tried it.

Every company has a Cheetos guy. They just never get the chance.

That's what we're fixing with Remix.

[Phil Chen @philhchen]

https://t.co/oMoEAYkqGl

[Chamath Palihapitiya @chamath]

https://t.co/vPrPSUjTJG

[Moysei @0xMoysei]

Karpathy just wrote the manual for Claude + Obsidian as a real second brain.

Most vaults die the same way. A year of saved articles and highlights. None of it linked. The graph rots while it still looks impressive.

So he moved the upkeep to the model. You curate sources and ask questions. Claude files, links, and reconciles. You keep judgment. It keeps the books.

raw belongs to you and never gets edited. wiki belongs to Claude. It isn't RAG. Your sources compile once into linked pages and compound from there.

9 rules. Start with 10 sources, not 10,000.
Most people hoard notes. This turns them into a brain that maintains itself.

[DAN KOE @thedankoe]

https://t.co/7l7Jef99QZ

[Sherif Zaidan @SherifZaidan]

Hell of an outlook by Satya!

[Satya Nadella @satyanadella]

https://t.co/vLmiBKTtX3

[Avi Chawla @_avichawla]

Karpathy said something you'll regret ignoring:

"Remove yourself as the bottleneck. Maximize your leverage. Put in very few tokens, and a huge amount of stuff happens on your behalf."

Loop engineering is the exact thing that does that.

In a hand-run session, the operator handles two things:

- deciding what the agent runs next
- and checking its output before the next step

Both are manual, and both decide how far the agent gets on its own without the operator.

Loop engineering moves both steps into the system.

A core operating structure surrounds the loop, and the diagram below depicts it.

- A schedule decides what to run
- Loop is the maker that produces the work
- A separate checker agent grades the output
- A file on disk holds the state they both read.

The loop runs until either done, max iterations, or an exhausted budget.

Here are some practical engineering considerations:

1) A model grading its own output justifies what it already did instead of catching where it failed.

That's why a separate checker's findings return to the maker as the next instruction. And the cycle repeats until the checker finds nothing left to fix.

2) A loop with no stop condition burns tokens, and the cost climbs fast once sub-agents and long runs add up.

That's why the exit must be set before the loop runs, not while it is running.

A simple exit could be:
↳ fix only the major issues, run one final pass, and stop after two loops, with "all tests pass and lint clean" as the rule that ends it.

3) State has to live on disk, not in context.

The model forgets everything between runs, so an MD file or a knowledge graph holds what is done and what is still open.

Each run reads it and writes back to it, which lets a loop pick up again after days.

4) The lower the verification bar, the safer the loop.

Boring, repetitive checks like a stale version string or a missing test are trivial to verify, so a loop runs them with little risk while the operator is away.

Judgment-heavy work is loopable too, but only as far as the checker can confirm the result.

Let's look at how an unattended loop fails in two ways.

1) It reports done when nothing is actually verified.

The separate checker exists to prevent it, but it merges code faster than anyone reads it, so over weeks, the team stops understanding its own codebase while every check stays green.

Green tests say the code passed the tests, not that anyone knows what shipped. Someone still has to read what the loop merges.

2) The checker keeps a running loop honest, but it only catches failures inside a run.

The harness around the loop, like the prompts, tools, and checks wrapped around the model, still drifts and breaks in production as models change.

That repair loop is usually run by hand based on observability traces.

My co-founder wrote a detailed walkthrough (with code) on making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it cannot recur.

Read it below.

[Sherif Zaidan @SherifZaidan]

Thank you!

[Josef Chen @josefchen]

Launching our new paper on arXiv: we trained the largest multilingual food model ever built.

4.1M recipes. 7 languages. 1,790 ingredients. 300 dimensions.

All of human cooking compressed into 2 megabytes.

[Hesham Ghandour @heshamghandour]

Everyone is learning to use coding agents. Not everyone can safely touch production.
That gap is the next thing that gets closed.
When it does, the number of real contributors to real software will catch up fast.

[Sherif Zaidan @SherifZaidan]

Moving from productivity to capability focus is why AI will have significantly more impact than most anticipate

[Sherif Zaidan @SherifZaidan]

Attention is all you need and the sequel is harness is all you need

[elvis @omarsar0]

// Code as Agent Harness //

100+ page report on all things related to agent harnesses.

(bookmark it)

In particular, the survey summarizes methods and applications of code as agent harness.

This paper makes a strong case that code-as-harness might be the key to moving us towards a broader science harness engineering.

Is code all you need? Maybe.

Regardless, the paper argues that future systems must have the following four properties: executable, inspectable, stateful, and governed.

Paper: https://t.co/bcNtSpSsQq

Learn to build effective AI agents in our academy: https://t.co/1e8RZKs4uX

[Sherif Zaidan @SherifZaidan]

We kinda of reached that conclusion at the same time ;)

[Andrej Karpathy @karpathy]

This works really well btw, at the end of your query ask your LLM to "structure your response as HTML", then view the generated file in your browser. I've also had some success asking the LLM to present its output as slideshows, etc.

More generally, imo audio is the human-preferred input to AIs but vision (images/animations/video) is the preferred output from them. Around a ~third of our brains are a massively parallel processor dedicated to vision, it is the 10-lane superhighway of information into brain. As AI improves, I think we'll see a progression that takes advantage:

1) raw text (hard/effortful to read)
2) markdown (bold, italic, headings, tables, a bit easier on the eyes) <-- current default
3) HTML (still procedural with underlying code, but a lot more flexibility on the graphics, layout, even interactivity) <-- early but forming new good default
...4,5,6,...
n) interactive neural videos/simulations

Imo the extrapolation (though the technology doesn't exist just yet) ends in some kind of interactive videos generated directly by a diffusion neural net. Many open questions as to how exact/procedural "Software 1.0" artifacts (e.g. interactive simulations) may be woven together with neural artifacts (diffusion grids), but generally something in the direction of the recently viral https://t.co/z21CP5iQfu

There are also improvements necessary and pending at the input. Audio nor text nor video alone are not enough, e.g. I feel a need to point/gesture to things on the screen, similar to all the things you would do with a person physically next to you and your computer screen.

TLDR The input/output mind meld between humans and AIs is ongoing and there is a lot of work to do and significant progress to be made, way before jumping all the way into neuralink-esque BCIs and all that. For what's worth exploring at the current stage, hot tip try ask for HTML.

[Rahul Garg @rahul_garg]

This is what Palantir is.

[Neha Sharma @hellonehha]

After reading @AnthropicAI blog on Agentic AI. spent some time to create a mental model to understand how to design, and explain Agentic AI architecture

Define a task/goal - what you want agent to do achieve?

1. Orchestration layer : it is your control panel

3. Agents layer: this layers made of agents (multi /specialised)

4. tools: your tools are made of this layer (web search, DB, APIs etc)

5. memory: this is the brain to store information - long or short term etc.

6. monitoring : This is the most crucial to monitor each and every step

7. Reliability & failure management: identify errors, retry, fallback, involve human

8. Governance and security: compliance, audit, auth etc.

[Sherif Zaidan @SherifZaidan]

Now that’s edge computing

[David Hendrickson @TeksEdge]

This is crazy! @AMD jumping into the AI game by branding their own Inference Box. Sovereign AI is the future. ✊ Fight the power!

[Hesham Ghandour @heshamghandour]

Underrated tweet

[Sherif Zaidan @SherifZaidan]

@HerselmanI Oh boy, this is just hits hard

[Sherif Zaidan @SherifZaidan]

@vasuman Amazing read!
“When you build for the documented process, you automate 70% of the volume and break on 30%. The 30% that breaks creates more work for the team than they had before, because now they have to fix the AI's mistakes on top of doing the work.” Summarizes the pain!

[Sherif Zaidan @SherifZaidan]

A must read ..
“When you build for the documented process, you automate 70% of the volume and break on 30%. The 30% that breaks creates more work for the team than they had before, because now they have to fix the AI's mistakes on top of doing the work.”

[vas @vasuman]

https://t.co/YlOT9k0U7E

[Sherif Zaidan @SherifZaidan]

I’m just going to leave this here

[Aakash Gupta @aakashgupta]

John Gottman can predict divorce from three minutes of footage with 91% accuracy. He's spent 40 years figuring out why.

He runs a Love Lab at the University of Washington. After observing 3,000+ couples, he isolated what actually keeps long marriages together.

The frequency of conflict barely shifts from year 1 to year 40. Old couples argue at roughly the same rate as newlyweds.

What changes is the ratio. Stable couples maintain 5 positive interactions for every 1 negative during a fight. Divorcing couples hover at 0.8 to 1. Below parity the marriage is structurally finished and the paperwork is lagging the math.

Then there's a separate metric Gottman calls the "bid." A small reach for connection during the day: a glance, a comment about the weather, a hand on a shoulder. Three possible responses: turn toward, turn away, turn against.

Couples who stayed married six years later turned toward bids 86% of the time. Couples who divorced turned toward them 33% of the time. That single number predicted longevity better than anything else Gottman had measured.

The photo on the plane is what 86% looks like at year 40. Two people who reached for each other thousands of times, in small glances and side comments, until reaching back stopped requiring a decision.

Forgiveness in old marriages is a five-second movement repeated until it becomes posture.