@Render DevEx Engineer
Phoenix Arizona
Joined December 2022
- Tweets799
- Following686
- Followers317
- Likes1.9K
Dylan B retweeted
Sundar Pichai on the earnings call:
'This rapid progress underscores our incredible model momentum. We are at the point where AI is helping us increase our training and launch velocity. I would expect the next twelve months to see continued acceleration because of RSI.'
Thoughts on agentic video editing from the CEO at Veed
My thoughts on the agentic video editing wave:
1. There won't be one winner in agentic video editing. Speed, use case and workflow will always matter. Just as Cursor moves upmarket while Lovable caters to non-technical users, specialised video tools will continue to serve different audiences, even as general-purpose agents improve.
2. Every major AI leap unlocks new product categories. Since GPT-3.5, we've seen coding, 3D and presentations. Opus 5.5 and Google's vision-language models are now unlocking agentic video editing. The edits still look more like websites than videos, but this is the worst they'll ever be.
3. Editing costs will collapse, and the number of creators will explode. Basic edits could go from dollars to cents within a year, with huge speed improvements. Frontier models will still command a premium. As editing becomes effortless, recording content might be the biggest bottleneck.
4. The best editors might be the biggest critics of agentic editing. Just as experienced engineers initially resisted AI-generated code over quality and maintainability, I think professional editors will eventually come around as the tools improve.
5. The real magic is in iteration. Getting 80–90% of an edit right on the first attempt is great, but making it excellent requires much more iteration. The way creators give feedback, refine edits and make videos feel distinctly theirs is where these tools will become truly magical
6. Anthropic's focus on coding enabled agents to build videos using HTML/CSS, SVG, browser rendering and OpenCV. Packages like Hyperframes, Rebooshed and VEED's OpenEdit gave LLMs editing capabilities they previously lacked. Opus 5.5 now makes many of those use cases redundant.
7. Chat alone won't be enough for video editing. Chat will be central, but video operates across time and X, Y and Z coordinates. More sophisticated UI will be needed to make great edits.
8. Brand consistency and repeatability remain unsolved. A Casey Neistat video feels distinctly his because of intentional creative decisions. Creators and brands need that same predictability across hundreds of edits. Even vibe coding hasn't solved this well (yet).
9. Basic editing won't be a long-term moat. Anthropic, Google and OpenAI will eventually offer it. Deeper workflows, specialised use cases and excellent mobile experiences will drive differentiation.
10. Don't reinvent professional editing tools. Building non-linear timelines is incredibly hard. Agentic video tools should focus on creating great first cuts and making it easy to hand them off to existing professional editing tools.
Overall, the next six months will be noisy!
But video editing has never been winner-take-all.
And I do NOT think that will change.
Hope this helps.
Dylan B retweeted
You can now give every @render API key the exact permissions it needs, and no more. In less than 30 seconds.
youtu.be/9ldllK7qZu8?si=xwNB…
This is honestly huge for agentic use.
I think we will look back and be in disbelief we used to give agents blanket read/write permissions over everything.
Now on Render you can scope your API keys and agents permissions to particular resources only. Huge risk reduction!
Give every API key only the access it needs.
Scoped API Keys are now in private beta on Render. Choose which actions a key can perform, without handing a CI job, agent, or integration all of your permissions.
Learn more and request access: render.com/blog/scoped-api-k…
Dylan B retweeted
extremely good explanation
Many of you don't understand how serious this is, so let me break it down.
In computer science there is a famous kind of puzzle called 3-SAT. You are given a long list of yes-or-no switches and a set of rules about how they must be arranged, and you have to find a combination that satisfies every rule. The obvious way to solve it is to try every combination, but each new switch doubles the number of possibilities, so a puzzle with a few hundred switches would take longer than the age of the universe to brute force.
For decades, the smartest people in the field found clever tricks that made this a little faster, but every trick still hit the same wall: the time required kept exploding as the puzzle grew.
About 25 years ago, two computer scientists, Russell Impagliazzo and Ramamohan Paturi, working with Francis Zane, turned that wall into a formal idea.
They proposed the Exponential Time Hypothesis, which says this explosion is not a failure of human cleverness but a law of nature. No algorithm, however brilliant, will ever solve 3-SAT without the time blowing up exponentially. Nobody could prove it, but almost everyone believed it, and it became one of the foundations of modern computer science.
Researchers used it as a measuring stick. If you could show that solving some other problem quickly would also crack 3-SAT quickly, you had shown that problem was hopelessly hard too. Hundreds of papers, across scheduling, graphs, logic and much more, rest on this one assumption.
Now an internal AI model at OpenAI claims to have broken it. It says it found an algorithm that solves these puzzles meaningfully faster than the hypothesis allows, and it has checked the proof in a computer verification system called Lean.
And here is the remarkable part: the very people who proposed the hypothesis, Impagliazzo and Paturi, along with MIT's Ryan Williams, are now leading the public review of whether a machine has disproved their own idea.
So what happens next? If the disproof holds, a large part of theoretical computer science has to be revisited.
Every result that said "this problem cannot be solved faster, assuming ETH" loses its foundation, and researchers will have to work out which of those walls were real and which were simply where we stopped looking. It does not mean everything becomes easy. The new algorithm is still slow in absolute terms and this is not the famous P versus NP problem being solved.
But it means our map of what is possible was wrong in a place we were very confident about, and it was an AI that redrew it. If the disproof fails, the hypothesis survives and the field breathes out, but we will still have watched an AI produce serious, checkable work on one of the deepest questions in the discipline, closely enough that the founders of the idea had to take it seriously. Either way, something has shifted.
If you are worried you might be exposed to the PHP vulnerability
If you are wondering whether your website is affected, we have packaged a Codex skill to help check.
Point your Codex at this repo to guide you through it: github.com/openai/php2shell-…
Agreed this is a pain point but I think its actually setting up the environment for the agents -- giving them access and context to all the needed platforms e.g. notion, email, analytics, etc
Dylan B retweeted
Manage your Render infrastructure without leaving the terminal.
Learn how to:
- Trigger deployments
- Manage Postgres & KV stores
- SSH directly into web services
- Install Render Agent Skills
- Automate CI/CD pipelines with non-interactive mode
Full video:
youtube.com/watch?v=pILqLLFi…
Dylan B retweeted
We're launching fast, fully-managed shared filesystems for sandboxes, workflows, and every other service type on @render. Sign up to get early access!
render.com/shared-filesystem…
Come say hi at Booth #734 tomorrow and Friday!
Bring your questions about @render and get some awesome Render T-shirts from our amazing design team!
Agent workloads are unpredictable by definition. Is the next request 3 tasks or 400?
Provisioning compute assumes you know the answer.
Our answer is Application-Defined Compute. Render CEO @anuraggoel explains it tomorrow at @WeAreDevs. 11 AM, Stage 1.
Find us at booth #734 after.
Jev is WILD for SEO audit 🤯
in 45.1 seconds it read all 586 pages on my site and rebuilt the internal link map. 584 links placed, 139 pages it refused to link because nothing honestly fit. total cost $0.21.
Claude Opus 5, same 586 pages, same clock, got through 21 of them and spent $1.43.
per page that is ~190x cheaper. the full Opus pass would have run $43.
internal linking is the perfect Jev job. it is not writing, it is 8,790 yes/no calls: does this page have a real reason to link to that one, and is there anchor text already sitting in the copy. that is a classification problem, and we have been paying frontier prices to do it one page at a time.
what you are watching: left column is Jev, right is Opus, same queue, same rubric. the run stops the moment Jev finishes so Opus stops burning tokens.
coming soon to @distribb_io + connector + gpt plugin
We just ran Jev on our WebMCP benchmark.
The result: basically broke the benchmark.
Jev + Mercury 2.5 (a fast, low-cost LLM) using WebMCP solved 100% of the tasks at roughly 112× lower model cost than GPT-6 Astra using computer use with code execution. Compared to Astra using screenshot-based computer use, the model cost was 245× lower (!).
We also compared Jev operating the browser with and without WebMCP.
We used Browser Use’s open-source Ultrafast, with some improvements to the harness to make it more reliable across the benchmark.
Jev’s browser-control accuracy on its own was not amazing - adding WebMCP nearly doubled the number of solved tasks, from 25/49 to 49/49, while reducing model cost by 18% (more on why below).
The benchmark and methodology are fully open and reproducible.
Full results: webmcp.com/benchmark
A few words on how the Jev + WebMCP harness works and why this is exciting:
Jev receives text as input and a set of discrete options it can choose from. With WebMCP, those options are the tools exposed by the website. At each step, Jev sees the task, the available tools and previous results, then picks what to do next.
The limitation is that Jev can’t generate arbitrary text, which you need for tool arguments. For example, it can choose the search_products tool, but it can’t generate the search query itself.
So we split the work: Jev picks the tool and Mercury 2.5 generates the arguments if needed.
This works well because turns out most of the cognitive load in these tasks is around choosing the right action. The argument generation itself is relatively simple, so we can delegate to a small and very fast model. We used Mercury, which outputs 1,000+ tokens/sec and is very cheap.
The result is a pretty simple combination: Jev for tool selection + Mercury for arguments + WebMCP for the interface. It ends up being very reliable, very fast, and very cheap.
A few words about Ultrafast and why do we think it underperforms:
Without WebMCP, Jev chooses from the page’s controls: which button to click, which field to fill, or which option to select.
But choosing a valid button is different from choosing the right next step. The agent still has to navigate menus, understand forms, recover from errors and recognize when the task is actually complete.
Our hypothesis is that WebMCP makes the decision space much simpler. Instead of figuring out a sequence of clicks through a website, Jev chooses explicit actions that directly advance the task.
@typesafeai itself documents weaker accuracy on questions requiring multiple reasoning steps. WebMCP moves much of that complexity into the website’s tools, leaving Jev with clearer decisions and fewer opportunities to go wrong (in a sense WebMCP "compresses" a sequence of clicks into one tool call).
Our modified Ultrafast setup solved 25/49 tasks - that is a result for our particular implementation and benchmark, not a universal limit on Jev or Browser Use. We are open to more harness optimization to get this result to perform better, feel free to directly contribute to the benchmark here: github.com/nekuda-ai/WindTun…
Browser-use ultrafast: github.com/browser-use/jev-u…
