You do important. AI does boring stuff. Built automation systems generating $50K+ for clients Founder leverage, not founder burnout Free tools ↓
Sponsorships 📩
Joined April 2014
- Tweets7.5K
- Following235
- Followers5.5K
- Likes9.2K
From experience battling plenty of hallucinations, I can say that when building production-level AI agents, knowledge equivalent to a Claude Certified Architect qualification is essential.
Most indie founders lose leads in the first 10 minutes. Not from bad pitches. From silence.
Speed beats polish. A reply in 10 seconds feels personal. A reply in 10 hours feels like a newsletter.
Form to n8n to AI-drafted WhatsApp or email, out the door before the lead closes the tab. No sales team. Just automation that doesn't sleep.
What's your average reply time right now?
Shadow testing catches 80% of agent failures before a user ever sees them.
Most teams ship and wait for things to break. That's the experiment. Users pay the cost.
Run the new agent silently next to the live one. Diff every decision. Edge cases land in a log instead of a support ticket.
Production signal, zero production risk. Who's running shadow mode in their stack?
Archit Jain retweeted
SpaceXAI and @cursor_ai are now working closely together to create the world’s best coding and knowledge work AI.
The combination of Cursor’s leading product and distribution to expert software engineers with SpaceX’s million H100 equivalent Colossus training supercomputer will allow us to build the world’s most useful models.
Cursor has also given SpaceX the right to acquire Cursor later this year for $60 billion or pay $10 billion for our work together.
Interesting times
Introducing GLM-5.1: The Next Level of Open Source
- Top-Tier Performance: #1 in open source and #3 globally across SWE-Bench Pro, Terminal-Bench, and NL2Repo.
- Built for Long-Horizon Tasks: Runs autonomously for 8 hours, refining strategies through thousands of iterations.
Blog: z.ai/blog/glm-5.1
Weights: huggingface.co/zai-org/GLM-5…
API: docs.z.ai/guides/llm/glm-5.1
Coding Plan: z.ai/subscribe
Coming to chat.z.ai in the next few days.
Netflix's VOID doesn't just erase objects. It simulates what happens next.
Standard video inpainting fills the gap. VOID models the consequence. Remove the person holding a guitar - the guitar falls. Naturally. That's not inpainting. That's scene understanding.
Under the hood: CogVideoX as the base, SAM2 for segmentation, Gemini for scene analysis. The physics-aware layer predicts downstream object behavior after removal, not just what the background looks like.
It beat Runway in human evals 64.8% vs 18.4%. Netflix dropped it open-source on Hugging Face on April 3.
The real unlock isn't cleaner edits. It's that video AI is starting to model causality, not just appearance. That's a different category of capability entirely.
Scaling compute is the wrong instinct.
By the time you provision more, the bottleneck already hit. You lost.
The fix isn't more resources. It's earlier signals.
Lightweight agents watch workload patterns continuously. Not current load. Trends. When data suggests a spike forming, the swarm redistributes tasks before saturation kicks in.
Lead queues, inventory checks, data pipelines. All stabilize. Zero over-provisioning.
We ran this across three high-volume automations. Throughput held. Costs dropped. No emergency scaling events.
The difference isn't infrastructure. It's timing.
You're not scaling behind demand anymore. You're scaling intelligence ahead of it.
Stop chasing the wave. Predict it.
Your agent is already learning. You're just not capturing it.
Every override, edit, or rejection is a signal. Most teams throw it away.
Builders who win aren't scheduling retraining cycles. They're building workflows where correction happens continuously, from day one.
The gap between a mediocre agent and a sharp one isn't model quality. It's captured versus ignored feedback.
An agent with embedded learning loops absorbs every correction without a formal retraining event.
Deployment isn't the finish line. It's when the real training starts.
The teams losing are treating a live system like a shipped product.
Your LLM pipeline will fail. Build for it anyway.
Single-prompt pipelines are fragile. One bad API call kills everything. Most builders patch failures later. That's the wrong order.
Chain prompts in sequence. Bake fallback paths in from day one. Step 2 fails? Reroute to an alternative prompt. Ambiguous output? A secondary prompt clarifies before anything moves forward.
Customer support flows and data pipelines stay live. Even when individual calls break.
This isn't complex engineering. It's a decision made at the start.
Failure recovery isn't an edge case. It's the gap between a demo someone claps for and a system someone pays for.
One agent beats five specialized ones. Here's why.
Most builders spin up separate agents for every task. Researcher. Writer. Analyst. Each siloed. Each handing off to the next.
That instinct is wrong.
Role-switching agents adapt mid-task to what the workflow actually needs. Context stays intact. No handoff loss. No reloading state. Fewer agents means fewer failure points, less orchestration overhead, faster fixes when something breaks.
I've seen multi-agent pipelines collapse under their own complexity. Single adaptive agents don't have that problem.
The hard part isn't building more agents.
It's building one smart enough to know which version of itself the task needs right now.
Shadow testing catches 80% of agent failures before users see them.
Run the agent silently alongside your live system. Its outputs go nowhere. No user touches them.
You just diff its decisions against the live workflow. Every divergence gets flagged.
Edge cases that would've broken real users get caught in a log instead.
Most teams ship and wait for things to break. That's the experiment. That's the cost.
Shadow testing makes the pre-ship phase the real experiment.
Production-quality signal. Zero production risk.
You don't learn if an agent works by shipping it. You learn by running it where failure is free.
Optimizing tokens is the wrong target.
Tokens are a proxy. The real metric is cost-per-successful-outcome.
A high-token run that finishes beats a low-token run that fails and retries 3x. Every time. Retries are where your budget actually dies.
The fix: route heavy reasoning to a capable model. Hand formatting to a lighter one. Teams running this in high-volume deployments cut costs 40% without touching success rates.
When budget pressure hits, truncate reasoning paths. Never drop quality thresholds.
Cheaper agents that fail more often are just expensive agents in disguise.
Smarter agents still fail. Recovery is the real architecture.
Most builders optimize for the happy path. Production agents hit rate limits, malformed outputs, broken tool calls - constantly.
The planner isn't what matters. What happens after step 4 explodes does.
Three changes that actually work:
Detect failure at the step level, not the workflow level.
Re-plan from the point of failure, not from scratch.
On retry, shift strategy - same action, different parameters.
Teams running self-correcting loops see 3x fewer production failures than linear chains.
Fragile agents are designed for success. Resilient ones are designed for recovery.
That's the only mental model that matters in prod.
Long agents don't have to drain your token budget.
Most builders treat cost as fixed: longer task, bigger bill. That assumption is wrong.
Memory compression changes the math. Instead of dragging full conversation history forward, the agent summarizes past steps into compact state. Keeps what matters. Drops what doesn't. Stays sharp across hundreds of steps.
This makes persistent workflows economically viable. Compliance monitoring. Lead nurturing. Research loops. Not just possible - profitable.
The unlock isn't faster models or bigger context windows. It's smarter memory architecture.
Token bloat isn't inevitable. It's a design choice you're making by default.
Smarter models aren't your bottleneck. Structure is.
Most teams rewrite the same agent logic every deployment. Planner, executor, verifier - fresh each time. That's not iteration. That's expensive repetition.
Modular blueprints fix this. Separate roles into reusable components. Snap them together instead of rebuilding from scratch. Non-technical teammates assemble workflows without touching code. Same architecture runs across sales, support, and ops - swap context, keep structure.
Faster deployments. Fewer failure points. Not because the model improved. Because they stopped reinventing the same wheel every run.
The speed advantage isn't a better model. It's a better pattern you only build once.
Triggering agents is the wrong mental model.
Most builders design agents that wait to be called. Real leverage is agents that call themselves.
An agent watching inboxes, calendars, and data streams doesn't wait for a prompt. It pattern-matches against conditions and self-queues before any human notices the problem.
That's the gap between a reactive tool and an always-on sentinel. Teams running this architecture kill response lag on operational issues before disruption surfaces.
You're not building for inputs. You're building for conditions.
The agent that waits to be asked is already too late.
Archit Jain retweeted
Vision pipelines are eating back-office ops.
A vision-enabled LLM can now read an invoice, extract line items, flag anomalies, and route to the right approver - no human needed for the boring parts. What used to require a custom parser and a dev sprint now runs as a single agent workflow.
The flow: image drops in, structured data comes out. Vendor, amounts, dates - all parsed. Approval logic chains off that extracted data automatically. Non-technical operators configure the rules. Devs wire the pipeline once and move on.
Teams running this are cutting back-office processing time by around 50%.
The shift is simple: once images are just another input type, the surface area for automation doubles overnight. Your workflow can see now. That changes what's possible.