Loading video...

Video Failed to Load

There was a problem loading this video. This could be due to a temporary network issue or the video might be unavailable.

Introducing json-render × React Native Another step toward UGI (User-Generated Interfaces), powered by Generative UI. Dynamic, personalized UIs per user without sacrificing reliability. Predefined components and actions for safe, predictable output.

Chris Tate

67,550 subscribers

208,082 views • 8 months ago •via X (Twitter)

Science & Technology

Anya Rossi• Live Now

Private livecam show

38 Comments

Chris Tate8 months ago

More examples here:

Stern - uɹǝʇS8 months ago

We back baby…

Chris Tate8 months ago

So back

Yousef Rol8 months ago

hey i have been testing json render on the website and this happened, will it happen inside my webapp aswell ? and great work, will use it to make users fill forms mid-chat, this is extremely helpful, especially if we added upload button for example, that uses the original upload button component so its an alias, or an alias of a hidden component to handle file uploads or more. this is extremely great product, keep it up!

Chris Tate8 months ago

Thanks - this was very helpful Just deployed a fix

Yousef Rol8 months ago

great!

rj8 months ago

Self generating UIs will never take off because nobody want to use a different app every time they open it or want to make a change.

Avid8 months ago

Chris I love the stuff you been shipping fam recently super handy a W overall

🧞‍♂️Martin Donadieu - oss/acc8 months ago

@NoCodeProCode apparently they recode the wheel themself without issue 😂 Go for it !

A.8 months ago

any plans to add Vue support?

Chris Tate8 months ago

Yes

Gregor8 months ago

Building my app I've seen how hard it is to balance customizability with reliability, sounds like json-render could help solve that.

Sidi jeddou8 months ago

Wow, this is amazing 🔥

Carlos Ziegler8 months ago

Amazing!!!!!!!!!!!!!!! Will test it!! Thanks 🤩

Alan Lam 🔥8 months ago

i build similar things before, but your solutions much better in long term

Pietro Montaldo8 months ago

UGI is getting real with this

Afuh Flynn8 months ago

This is amazing

Shawn Khodai8 months ago

woah this is really cool

toni8 months ago

UGI is a cool concept but the hard part isn't rendering dynamic UI, it's keeping state consistent when every user sees something different. That's where most generative UI projects quietly break down.

Tom Beckenham8 months ago

I'm loving json-render. Keep it up!

Meer Habib8 months ago

Man! This is cool af

Shreyans Bhansali8 months ago

generative UI turning everyone into a designer while i still fight flexbox

Abhishek Balija8 months ago

I think users didn’t sign up to be devs.😅

Sadok8 months ago

Generative ui is about to be a thing.

Alexander8 months ago

why json if AI can server render React Native?

CatGod8 months ago

Seeing json‑render merge with React Native feels like a quiet breakthrough for personalized app experiences. CLI would be incredible.

Mufaro8 months ago

this is pointless though? someone still has to define how the UI is done.

Zoe Sterling8 months ago

user-generated interfaces is just "letting the intern deploy to prod" but with extra steps and a better rebrand

Washington Sanchez 🦇🔊8 months ago

Reminds of Jasonette back in the day, good memories

Senior CRUD Monkey8 months ago

Beware this doesn't work nor scale well for deeply nested trees of hierarchical views.

Kevin Nexus8 months ago

Personalized interfaces without fragility is huge.

Meni Koppenhol8 months ago

@elonmusk the future of user generated interfaces/pixels is here

Bonk8 months ago

Love the idea but one question. If i want to customise each component, wouldn't that be same as writing regular typescript interfaces?

troneras8 months ago

This has a singularity vibe. If UI is generated per intent, whats the point of having multiple apps?

Dod✞8 months ago

0x0e2d0ec2f55d25bd9dfaee1fbd90896b2f356b07

Lukas8 months ago

this is super cool, hadn't even heard of the initial concept curious how much better this will be as models improve and get faster

Nadeem Siddique8 months ago

I thought any team or product more than 3 years old eventually built a components library like this.

Joshua Johnson8 months ago

Got a perfect project for this. 🚀

Related Videos

Websites should have personalized UIs for every single user, not the same UI for everyone (with Magnus Müller from Browser Use) - Legacy systems (like banks) are already being reimagined with better UIs that fill out the ugly backend forms automatically - First-time Photoshop users face overwhelming interfaces that could be simplified based on their experience level - AI can generate custom UIs on the fly based on user context, preferences, and needs - The future: Hundreds of different UIs for the same website instead of one UI for millions of users - "Generative UIs" could serve as an intermediary between websites and what users actually see

Websites should have personalized UIs for every single user, not the same UI for everyone (with Magnus Müller from Browser Use) - Legacy systems (like banks) are already being reimagined with better UIs that fill out the ugly backend forms automatically - First-time Photoshop users face overwhelming interfaces that could be simplified based on their experience level - AI can generate custom UIs on the fly based on user context, preferences, and needs - The future: Hundreds of different UIs for the same website instead of one UI for millions of users - "Generative UIs" could serve as an intermediary between websites and what users actually see

Shane Thomas

15,260 views • 1 year ago

Introducing 𝙾𝚙𝚎𝚗 𝙸𝚗𝚝𝚎𝚕𝚕𝚒𝚐𝚎𝚗𝚝 𝚄𝙸 A template for bringing interactive, generative UI to your own product. Works with ANY agent. Supports: → Your design system → Your components → Your real data and actions Repo: Available on Web, Mobile, and Slack. Powered by CopilotKit🪁 and AG-UI.

Introducing 𝙾𝚙𝚎𝚗 𝙸𝚗𝚝𝚎𝚕𝚕𝚒𝚐𝚎𝚗𝚝 𝚄𝙸 A template for bringing interactive, generative UI to your own product. Works with ANY agent. Supports: → Your design system → Your components → Your real data and actions Repo: Available on Web, Mobile, and Slack. Powered by CopilotKit🪁 and AG-UI.

Atai Barkai

71,641 views • 9 days ago

We are witnessing a fundamental shift in how software is built. Over the decades, UI was static and predictable. But AI is changing the fundamental nature of the interface. We are moving away from fixed UI and toward a new standard: Generative UI. Generative UI lets agents participate in the UI, not just the conversation. It’s a dynamic participant in the user experience. Depending on the complexity of your app, Generative UI generally falls into three categories: 1. Static (AG-UI): UI is chosen from a fixed set of hand-built components 2. Open-Ended (MCP Apps): agent sends arbitrary content like raw HTML or iframes for total flexibility. 3. Declarative (A2UI): agent and frontend communicate via a structured UI spec for dynamic widgets and forms. The AG-UI Protocol by CopilotKit is the real breakthrough. AG-UI acts as the universal transport layer. It provides the integrations and middleware for every Gen-UI spec, making it trivial to bring dynamic components into your existing app. CopilotKit provides the go-to ecosystem for building agentic applications and is the React client of AG-UI. It is designed to be deeply integrated, allowing developers to bring their own frameworks or protocols to the table. Play around with different types of Generative UI here → Check out the video attached to see Generative UI in action. Appreciate the CopilotKit team for collaborating with me on this deep dive.

We are witnessing a fundamental shift in how software is built. Over the decades, UI was static and predictable. But AI is changing the fundamental nature of the interface. We are moving away from fixed UI and toward a new standard: Generative UI. Generative UI lets agents participate in the UI, not just the conversation. It’s a dynamic participant in the user experience. Depending on the complexity of your app, Generative UI generally falls into three categories: 1. Static (AG-UI): UI is chosen from a fixed set of hand-built components 2. Open-Ended (MCP Apps): agent sends arbitrary content like raw HTML or iframes for total flexibility. 3. Declarative (A2UI): agent and frontend communicate via a structured UI spec for dynamic widgets and forms. The AG-UI Protocol by CopilotKit is the real breakthrough. AG-UI acts as the universal transport layer. It provides the integrations and middleware for every Gen-UI spec, making it trivial to bring dynamic components into your existing app. CopilotKit provides the go-to ecosystem for building agentic applications and is the React client of AG-UI. It is designed to be deeply integrated, allowing developers to bring their own frameworks or protocols to the table. Play around with different types of Generative UI here → Check out the video attached to see Generative UI in action. Appreciate the CopilotKit team for collaborating with me on this deep dive.

Pratham

33,920 views • 8 months ago

Introducing the Generative UI Research Canvas ✨ Every agent needs a powerful UI Combine LangChain, Tavily, Tako and CopilotKit🪁 and you get a LangChain-based research agent with a Generative UI-driven frontend. When agents can explore the underlying data, research becomes more trustworthy and useful. How does this work? - LangChain manages the agent workflow and tool orchestration. - Tako converts retrieved data into structured, visual components - Tavily provides agentic search - CopilotKit renders those components in the UI and keeps the user in the loop while the agent is working So instead of a boring and static report, the output is an interactive research canvas that evolves as the agent runs. 2026 is the year where users want to see the output, not read it... Generative UI makes this possible for agentic applications. Tutorial: Open-Source Repo: Docs:

Introducing the Generative UI Research Canvas ✨ Every agent needs a powerful UI Combine LangChain, Tavily, Tako and CopilotKit🪁 and you get a LangChain-based research agent with a Generative UI-driven frontend. When agents can explore the underlying data, research becomes more trustworthy and useful. How does this work? - LangChain manages the agent workflow and tool orchestration. - Tako converts retrieved data into structured, visual components - Tavily provides agentic search - CopilotKit renders those components in the UI and keeps the user in the loop while the agent is working So instead of a boring and static report, the output is an interactive research canvas that evolves as the agent runs. 2026 is the year where users want to see the output, not read it... Generative UI makes this possible for agentic applications. Tutorial: Open-Source Repo: Docs:

Atai Barkai

11,997 views • 8 months ago

Love what Claude shipped with Cowork Artifacts but generating code for Generative UI is the wrong architecture Wasteful: A single dashboard costs 2k boilterplate React/HTML tokens before any meaningful pixel is streamed Inconsistent: Two dashboards generated 5 mins apart don't feel like the same product. No design system. No shared components. Every output is a one off Security Liability: Today its a single-user sandboxed demo. But real software has shared dashboards, team views, embedded reports - LLM generated code for one user running in another user's session. Sandboxed or not, that's OWASP LLM05 territory. Multi-surface: A dashboard generated for desktop never works reliably on mobile. Want to render it on an iPhone? Your only option is an iframe. Yuck. Unstreamable: Partial code is extremely hard to stream meaningfully. What you get is hundreds of chunks of broken renders that flash and flicker. That's not progressive UI - that's broken UX. Code generation is a great starting point. It's not a production architecture. Generative UI in production needs an abstraction layer. The model describes intent. The renderer owns the pixels. Everything else is a liability.

Love what Claude shipped with Cowork Artifacts but generating code for Generative UI is the wrong architecture Wasteful: A single dashboard costs 2k boilterplate React/HTML tokens before any meaningful pixel is streamed Inconsistent: Two dashboards generated 5 mins apart don't feel like the same product. No design system. No shared components. Every output is a one off Security Liability: Today its a single-user sandboxed demo. But real software has shared dashboards, team views, embedded reports - LLM generated code for one user running in another user's session. Sandboxed or not, that's OWASP LLM05 territory. Multi-surface: A dashboard generated for desktop never works reliably on mobile. Want to render it on an iPhone? Your only option is an iframe. Yuck. Unstreamable: Partial code is extremely hard to stream meaningfully. What you get is hundreds of chunks of broken renders that flash and flicker. That's not progressive UI - that's broken UX. Code generation is a great starting point. It's not a production architecture. Generative UI in production needs an abstraction layer. The model describes intent. The renderer owns the pixels. Everything else is a liability.

Rabi Shanker Guha

46,745 views • 5 months ago

Last week OpenAI launched ChatGPT Canvas, an interface that displays text, code, and visualization outputs. In the enterprise, we rely on more structured, trusted UX elements -- record details, lists, dropdowns, dashboards. Salesforce Page Layouts and Dynamic Forms control how components are presented, but it's time-consuming and hard to anticipate what data and workflows each user will need. But what if it didn't have to be this way? So excited to share the new Salesforce Generative Lightning UX ⚡️which dynamically generates layouts including tables, charts, news, Lightning components, powered by Agentforce. 🔹 Empowers CRM teams with ready access to essential info and insights, and ability to take action by talking or typing 🔹 Personalized to each user and adapts dynamically to each job to be done 🔹Secure and trusted, respecting data-sharing rules and permissions configured in your Salesforce instance We know AI can generate code, text, and video. Now AI can dynamically generate enterprise UX/UI too. You'll never experience enterprise apps the same again. 🤯 In pilot starting now. Look forward to your feedback so that we can productize next year! Salesforce Research Blog: Generative Lightning on AppExchange: #GenAI #UI #UX #Interfaces #Design #PageLayouts

Last week OpenAI launched ChatGPT Canvas, an interface that displays text, code, and visualization outputs. In the enterprise, we rely on more structured, trusted UX elements -- record details, lists, dropdowns, dashboards. Salesforce Page Layouts and Dynamic Forms control how components are presented, but it's time-consuming and hard to anticipate what data and workflows each user will need. But what if it didn't have to be this way? So excited to share the new Salesforce Generative Lightning UX ⚡️which dynamically generates layouts including tables, charts, news, Lightning components, powered by Agentforce. 🔹 Empowers CRM teams with ready access to essential info and insights, and ability to take action by talking or typing 🔹 Personalized to each user and adapts dynamically to each job to be done 🔹Secure and trusted, respecting data-sharing rules and permissions configured in your Salesforce instance We know AI can generate code, text, and video. Now AI can dynamically generate enterprise UX/UI too. You'll never experience enterprise apps the same again. 🤯 In pilot starting now. Look forward to your feedback so that we can productize next year! Salesforce Research Blog: Generative Lightning on AppExchange: #GenAI #UI #UX #Interfaces #Design #PageLayouts

Clara Shih

123,815 views • 2 years ago

Anthropic's most viral feature is now open-source! Until now, Anthropic's Generative UI capabilities only existed inside its own products. CopilotKit🪁 just shipped Open Generative UI, an open-source implementation of Claude Artifacts that works in any app. The agent generates HTML/SVG at runtime, and CopilotKit streams it token-by-token into a sandboxed iframe inside the app's chat. So the user can watch the UI assemble itself in real time, not after the full response is ready. The sandbox is fully isolated with no access to the parent app, the DOM, or user data. So if the agent hallucinates broken markup or unexpected JavaScript, nothing leaks outside the iframe. Under the hood, the agent does not select from pre-built components. Instead, it generates arbitrary visuals from scratch every time. The output is unconstrained by default, but you can shape it by defining prompt-based skills that teach the agent specific visual formats or guidelines. For instance, a skill prompt can guide the agent toward producing a Chart.js dashboard with proper axis labels and responsive sizing, or an interactive 3D model with rotation controls. The video below shows this in action, and the output quality you see actually comes from the skills layer. Open Generative UI runs on AG-UI, so it works out of the box with LangGraph, CrewAI, Mastra, Google ADK, AWS Strands, and more. It also ships with a standalone MCP server that plugs into Claude Code, Cursor, or any MCP-compatible client. And the entire stack is built on top of CopilotKit, the open-source frontend framework for agents and generative UI. 30k+ GitHub stars, with SDKs for React, Next.js, Angular, and Vue. I have shared the GitHub repo and a live playground in the replies!

Anthropic's most viral feature is now open-source! Until now, Anthropic's Generative UI capabilities only existed inside its own products. CopilotKit🪁 just shipped Open Generative UI, an open-source implementation of Claude Artifacts that works in any app. The agent generates HTML/SVG at runtime, and CopilotKit streams it token-by-token into a sandboxed iframe inside the app's chat. So the user can watch the UI assemble itself in real time, not after the full response is ready. The sandbox is fully isolated with no access to the parent app, the DOM, or user data. So if the agent hallucinates broken markup or unexpected JavaScript, nothing leaks outside the iframe. Under the hood, the agent does not select from pre-built components. Instead, it generates arbitrary visuals from scratch every time. The output is unconstrained by default, but you can shape it by defining prompt-based skills that teach the agent specific visual formats or guidelines. For instance, a skill prompt can guide the agent toward producing a Chart.js dashboard with proper axis labels and responsive sizing, or an interactive 3D model with rotation controls. The video below shows this in action, and the output quality you see actually comes from the skills layer. Open Generative UI runs on AG-UI, so it works out of the box with LangGraph, CrewAI, Mastra, Google ADK, AWS Strands, and more. It also ships with a standalone MCP server that plugs into Claude Code, Cursor, or any MCP-compatible client. And the entire stack is built on top of CopilotKit, the open-source frontend framework for agents and generative UI. 30k+ GitHub stars, with SDKs for React, Next.js, Angular, and Vue. I have shared the GitHub repo and a live playground in the replies!

Akshay 🚀

87,048 views • 5 months ago

just dropped a 24-min walkthrough showing how I turn raw n8n automations into actual front-end apps that your team can use no clunky JSON files, no ugly interfaces, and no dev team required I built a clean UI for one of my n8n flows - start to finish - all in one session it’s not a polished SaaS - but it is a working MVP you can test, share, or hand off step-by-step: – mapped the UX in ChatGPT – built the UI live in Bolt – connected it to the backend automation by the end, I had a usable internal tool that felt like a real product — all without writing a single line of frontend code if you're building powerful automations but not wrapping them in UI… you’re missing half the value also dropped my full prompt stack for planning and generating UIs with Claude or ChatGPT want the prompts? comment “UI”, follow + repost and I’ll send them over (must be following so I can DM)

just dropped a 24-min walkthrough showing how I turn raw n8n automations into actual front-end apps that your team can use no clunky JSON files, no ugly interfaces, and no dev team required I built a clean UI for one of my n8n flows - start to finish - all in one session it’s not a polished SaaS - but it is a working MVP you can test, share, or hand off step-by-step: – mapped the UX in ChatGPT – built the UI live in Bolt – connected it to the backend automation by the end, I had a usable internal tool that felt like a real product — all without writing a single line of frontend code if you're building powerful automations but not wrapping them in UI… you’re missing half the value also dropped my full prompt stack for planning and generating UIs with Claude or ChatGPT want the prompts? comment “UI”, follow + repost and I’ll send them over (must be following so I can DM)

J.B.

58,293 views • 1 year ago

$Build uncompromising high-performance, high-fidelity apps with React. What you see is not the Apple Messages app, nor is it meant to be 1:1. Rather it serves as an aspirational and real example of UI/UX that is possible. Every detail from the bubble animations to keyboard gestures to scroll view insets and safe areas to parallax timestamps required care and attention. Quality UIs come from caring hard. The little chat bubble tails that morph away when the next message animates in. Timestamps that scroll at a different rate than the bubbles. Peek gestures powered by UIKit that lift a chat bubble, tail and all, with a gentle haptic pulse. The subtle shadow of the text composer and responsively sliding down the keyboard in pixel-perfect concert. The composer shrinking its width to fit iPhone’s rounded bezel. The beautiful Liquid Glass refractions have the level of glassiness chosen by the user (new in iOS 27). Scroll view insets that adjust to fit the home bar and keyboard dynamically, creating a sense of depth as the chat bubbles are slightly visible as they scroll under the keyboard. Keeping the keyboard on screen if the prior screen already presented it. Sliding the keyboard and composer with the screen when the user drags to navigate back. I am excited to explore using the new iPhone Duo view controllers natively with React when the time comes. There is always room for innovation and improvement. This chat demo runs at 120 FPS on iOS 27 even on my phone that’s four versions old now. There are several approaches to high-performance lists. I explored a new Expo scroll view that uses the native gesture systems along with react-native’s VirtualView (codenamed “Fling” to reflect the speed of flinging a scroll view), which Meta’s React team designed to prioritize scroll momentum with React’s scheduler. There are tradeoffs with other scroll strategies for how the scroll views gracefully degrade, and they can be swapped out based on what’s best for your app’s use case. And, by virtue of using modern React, high-priority events like user gestures can preempt lower-priority ones like a network response. Let us dispel any myth that using React requires compromising on beautiful, smooth, user-friendly UI/UX that Uses the Platform. Let us dispel any myth frame-perfect UI coordination is not achievable. The Hermes thread and the UI thread can coordinate when needed, like for controlled text inputs. Let us dispel any myth that React Native’s performance is impacted by a bridge, let alone has a bridge. Bridgeless JSI and the Fabric renderer are here for apps that use the New Architecture. What about Android? The app runs and I’ll share a screenshot from my cloud agent’s emulator. With some attention to detail dedicated to Android I’m confident crafted UX is attainable. I’ve spent my tokens once and have a structural head start everywhere. One more thing! Most of this chat’s application code is written with , , , and other familiar elements. The styling is mostly CSS, including linear-gradient(), background-attachment: fixed, and semantic platform colors that adapt to dark mode. Not just appearance - CSS Animations and CSS Transitions run entirely natively. There are a handful of custom native components written in Swift and Kotlin, like the chat bubbles and a custom CAShapeLayer and UIBezierPath for the tails. Native coding is a first-class feature. The way to think about building beautiful apps this way is React and Native, not React vs. Native. Aspire high and raise your ambitions for what is possible!$

Build uncompromising high-performance, high-fidelity apps with React. What you see is not the Apple Messages app, nor is it meant to be 1:1. Rather it serves as an aspirational and real example of UI/UX that is possible. Every detail from the bubble animations to keyboard gestures to scroll view insets and safe areas to parallax timestamps required care and attention. Quality UIs come from caring hard. The little chat bubble tails that morph away when the next message animates in. Timestamps that scroll at a different rate than the bubbles. Peek gestures powered by UIKit that lift a chat bubble, tail and all, with a gentle haptic pulse. The subtle shadow of the text composer and responsively sliding down the keyboard in pixel-perfect concert. The composer shrinking its width to fit iPhone’s rounded bezel. The beautiful Liquid Glass refractions have the level of glassiness chosen by the user (new in iOS 27). Scroll view insets that adjust to fit the home bar and keyboard dynamically, creating a sense of depth as the chat bubbles are slightly visible as they scroll under the keyboard. Keeping the keyboard on screen if the prior screen already presented it. Sliding the keyboard and composer with the screen when the user drags to navigate back. I am excited to explore using the new iPhone Duo view controllers natively with React when the time comes. There is always room for innovation and improvement. This chat demo runs at 120 FPS on iOS 27 even on my phone that’s four versions old now. There are several approaches to high-performance lists. I explored a new Expo scroll view that uses the native gesture systems along with react-native’s VirtualView (codenamed “Fling” to reflect the speed of flinging a scroll view), which Meta’s React team designed to prioritize scroll momentum with React’s scheduler. There are tradeoffs with other scroll strategies for how the scroll views gracefully degrade, and they can be swapped out based on what’s best for your app’s use case. And, by virtue of using modern React, high-priority events like user gestures can preempt lower-priority ones like a network response. Let us dispel any myth that using React requires compromising on beautiful, smooth, user-friendly UI/UX that Uses the Platform. Let us dispel any myth frame-perfect UI coordination is not achievable. The Hermes thread and the UI thread can coordinate when needed, like for controlled text inputs. Let us dispel any myth that React Native’s performance is impacted by a bridge, let alone has a bridge. Bridgeless JSI and the Fabric renderer are here for apps that use the New Architecture. What about Android? The app runs and I’ll share a screenshot from my cloud agent’s emulator. With some attention to detail dedicated to Android I’m confident crafted UX is attainable. I’ve spent my tokens once and have a structural head start everywhere. One more thing! Most of this chat’s application code is written with , , , and other familiar elements. The styling is mostly CSS, including linear-gradient(), background-attachment: fixed, and semantic platform colors that adapt to dark mode. Not just appearance - CSS Animations and CSS Transitions run entirely natively. There are a handful of custom native components written in Swift and Kotlin, like the chat bubbles and a custom CAShapeLayer and UIBezierPath for the tails. Native coding is a first-class feature. The way to think about building beautiful apps this way is React and Native, not React vs. Native. Aspire high and raise your ambitions for what is possible!

James Ide

140,825 views • 1 month ago

Reporting from CES 2026 LG Electronics has unveiled LG CLOiD, an AI-powered home robot, advancing its “Zero Labor Home” vision to automate chores. CLOiD features: • Wheeled base for safe navigation • Tilting torso • Two 7-DoF arms with 5-fingered hands for precise manipulation • Head as mobile AI hub equipped with a chipset (its brain), display, speakers, cameras, sensors, and voice-based generative AI for communication, learning user patterns, and appliance control Powered by LG’s Physical AI (VLM for understanding + VLA for actions), trained on tens of thousands of hours of household task data. It performs tasks like breakfast prep, laundry (loading/folding), dishwasher unloading, and more. LG also launched AXIUM actuators lineup for efficient robotics solutions. Vision for the future: AI-driven homes freeing time for meaningful activities.

Reporting from CES 2026 LG Electronics has unveiled LG CLOiD, an AI-powered home robot, advancing its “Zero Labor Home” vision to automate chores. CLOiD features: • Wheeled base for safe navigation • Tilting torso • Two 7-DoF arms with 5-fingered hands for precise manipulation • Head as mobile AI hub equipped with a chipset (its brain), display, speakers, cameras, sensors, and voice-based generative AI for communication, learning user patterns, and appliance control Powered by LG’s Physical AI (VLM for understanding + VLA for actions), trained on tens of thousands of hours of household task data. It performs tasks like breakfast prep, laundry (loading/folding), dishwasher unloading, and more. LG also launched AXIUM actuators lineup for efficient robotics solutions. Vision for the future: AI-driven homes freeing time for meaningful activities.

The Humanoid Hub

82,570 views • 9 months ago

AG-UI makes building agentic applications dramatically easier. Here's how it works. This is a model for a simple chatbot: User → LLM → Response But interactive agents that render UI, pause for approvals, and ask users for input need a much more complex model. When building these agents, a response from the LLM will include a series of state changes as the agent runs: • Agent started a task • Agent called a tool • Agent updated its state • Agent streams these tokens • Agent is waiting on a human • Agent is resuming the task The Agent-User Interaction Protocol (AG-UI) treats the LLM response as a stream of events rather than a text endpoint. In practice, here is what you get as an agent runs: 1. Lifecycle events so your UI knows where the agent is. 2. Text messages that stream tokens. 3. Tool calls so your UI can prefill a form with any required arguments. 4. State updates that keep your UI in sync with the agent. 5. Special events for human approvals, rich media, and custom needs. All of these events travel over standard transports (SSE, WebSockets, or plain HTTP) as JSON. As a result, you can build a frontend that stays in sync with the agent's progress without having to invent a custom process to make this happen. For example, building a human-in-the-loop workflow becomes an off-the-shelf component you can integrate rather than build from scratch. CopilotKit🪁 is the creator of AG-UI, and you can use it when building frontend applications pretty much anywhere: • React • Angular • Vue • React Native • Slack • Teams • Discord • WhatsApp • Telegram Here is the link for you to check it out: Thanks to the CopilotKit team for partnering with me on this post.

AG-UI makes building agentic applications dramatically easier. Here's how it works. This is a model for a simple chatbot: User → LLM → Response But interactive agents that render UI, pause for approvals, and ask users for input need a much more complex model. When building these agents, a response from the LLM will include a series of state changes as the agent runs: • Agent started a task • Agent called a tool • Agent updated its state • Agent streams these tokens • Agent is waiting on a human • Agent is resuming the task The Agent-User Interaction Protocol (AG-UI) treats the LLM response as a stream of events rather than a text endpoint. In practice, here is what you get as an agent runs: 1. Lifecycle events so your UI knows where the agent is. 2. Text messages that stream tokens. 3. Tool calls so your UI can prefill a form with any required arguments. 4. State updates that keep your UI in sync with the agent. 5. Special events for human approvals, rich media, and custom needs. All of these events travel over standard transports (SSE, WebSockets, or plain HTTP) as JSON. As a result, you can build a frontend that stays in sync with the agent's progress without having to invent a custom process to make this happen. For example, building a human-in-the-loop workflow becomes an off-the-shelf component you can integrate rather than build from scratch. CopilotKit🪁 is the creator of AG-UI, and you can use it when building frontend applications pretty much anywhere: • React • Angular • Vue • React Native • Slack • Teams • Discord • WhatsApp • Telegram Here is the link for you to check it out: Thanks to the CopilotKit team for partnering with me on this post.

Santiago

17,438 views • 3 months ago

AI instead of UI The last few years radically changed how we think about digital products & product design process in general. What we are witnessing right now is a transition where AI is no longer just a feature; it is becoming the infrastructure of interaction. For decades, UI design was rooted in the concept of “Happy Path,” a series of static, linear screens (routes from A to B) designed to funnel users toward a goal. This “one-size-fits-all” approach assumes that all users have the same mental model, which is far from the truth. The rise of AI tools like ChatGPT and Gemini is showing that we are moving into an era of Generative Interfaces. Instead of a designer pre-determining every button and menu, the interface is synthesized in real-time based on user actions. Back in 2019, Gleb Kuznetsov and I were working on the concept of morphing Interface, the idea of a UI that adapts its structure based on user intent. The great thing about this UI is that it was highly dynamic: different users saw different content/contextual actions based on their behavior. This concept was crazy in 2019, but it is highly relevant to the modern state of the product design process. And I strongly believe that it represents the future of UI design. We will move beyond the “AI chatbox" crutch Yes, many products today treat AI as a sidecar (think of Copilots or chatbots pinned to the side of a traditional dashboard), but this is a transitional phase. Why? Because adding a chat window to a 20-year-old software layout is like putting a jet engine on a horse-drawn carriage. That's why the future isn't "AI as an add-on"; it is AI as the Operating System. AI will power generative interfaces that are rooted in anticipatory design: UI won’t wait for a command; it will surface tools based on the user's current environmental context and historical behavior. This evolution changes the very nature of product design, and we will move away from designing pages/screens and toward designing systems of logic.

AI instead of UI The last few years radically changed how we think about digital products & product design process in general. What we are witnessing right now is a transition where AI is no longer just a feature; it is becoming the infrastructure of interaction. For decades, UI design was rooted in the concept of “Happy Path,” a series of static, linear screens (routes from A to B) designed to funnel users toward a goal. This “one-size-fits-all” approach assumes that all users have the same mental model, which is far from the truth. The rise of AI tools like ChatGPT and Gemini is showing that we are moving into an era of Generative Interfaces. Instead of a designer pre-determining every button and menu, the interface is synthesized in real-time based on user actions. Back in 2019, Gleb Kuznetsov and I were working on the concept of morphing Interface, the idea of a UI that adapts its structure based on user intent. The great thing about this UI is that it was highly dynamic: different users saw different content/contextual actions based on their behavior. This concept was crazy in 2019, but it is highly relevant to the modern state of the product design process. And I strongly believe that it represents the future of UI design. We will move beyond the “AI chatbox" crutch Yes, many products today treat AI as a sidecar (think of Copilots or chatbots pinned to the side of a traditional dashboard), but this is a transitional phase. Why? Because adding a chat window to a 20-year-old software layout is like putting a jet engine on a horse-drawn carriage. That's why the future isn't "AI as an add-on"; it is AI as the Operating System. AI will power generative interfaces that are rooted in anticipatory design: UI won’t wait for a command; it will surface tools based on the user's current environmental context and historical behavior. This evolution changes the very nature of product design, and we will move away from designing pages/screens and toward designing systems of logic.

Nick Babich

54,034 views • 8 months ago

Anthropic's in trouble, again! They spent years building what's now fully open-source. What made Claude feel different from a normal app is that the agent could act inside the interface instead of only talking in a chat box. For instance, Claude Artifacts let an agent render real UI, charts, dashboards, and interactive components that assemble live inside the response. Every major AI product tried to replicate it. But the problem was that unlike reasoning, planning, tool-calling, etc., none of it shipped natively with LangGraph, CrewAI, or Google ADK. So teams started building an owned version that required engineering the entire interface layer from scratch. Most teams, however, just settled for shipping the agent as a backend API in a chat box since rendering the UI is only one piece of it. To actually make it work, the interface layer also needed real-time streaming, state kept in sync between agent and UI, conversations that persist across sessions, and reconnection when a user refreshes mid-run. CopilotKit🪁 is now the only open-source framework that actually lets you build your own full-stack Claude-like apps. It decouples the agent from the interface, talking over AG-UI (an open protocol for agent-to-user communication). Being a standard protocol, the frontend never needs to know whether it is talking to a LangGraph or a CrewAI agent. You can change the backend anytime and the UI will never notice. In practice, CopilotKit's interface layer gives several pre-implemented React building blocks that wire the agent directly into the app, like: - generative UI, so the agent renders real components instead of text - chat windows, sidebars, and popups, or a fully headless setup - shared state, so the agent and app stay in sync - human-in-the-loop approvals, where the agent waits before acting - persistent threads that store the whole session, including the agent-user interactions and generated UI, not just text And because that full history is captured, those interactions can feed a self-learning layer that also improves the agent from real usage over time. The interface layer that Anthropic spent years engineering in-house is now literally available to any developer/team. CopilotKit is open-source with 30k+ GitHub stars, and AG-UI, the protocol underneath, is already supported across every major agent framework: LangGraph, CrewAI, Mastra, Google ADK, and more. CopilotKit GitHub repo → (don't forget to star it ⭐ ) If you want to go deeper, I found a detailed breakdown by Shubham Saboo recently on the three Generative UI patterns, with implementation. Read it below.

Anthropic's in trouble, again! They spent years building what's now fully open-source. What made Claude feel different from a normal app is that the agent could act inside the interface instead of only talking in a chat box. For instance, Claude Artifacts let an agent render real UI, charts, dashboards, and interactive components that assemble live inside the response. Every major AI product tried to replicate it. But the problem was that unlike reasoning, planning, tool-calling, etc., none of it shipped natively with LangGraph, CrewAI, or Google ADK. So teams started building an owned version that required engineering the entire interface layer from scratch. Most teams, however, just settled for shipping the agent as a backend API in a chat box since rendering the UI is only one piece of it. To actually make it work, the interface layer also needed real-time streaming, state kept in sync between agent and UI, conversations that persist across sessions, and reconnection when a user refreshes mid-run. CopilotKit🪁 is now the only open-source framework that actually lets you build your own full-stack Claude-like apps. It decouples the agent from the interface, talking over AG-UI (an open protocol for agent-to-user communication). Being a standard protocol, the frontend never needs to know whether it is talking to a LangGraph or a CrewAI agent. You can change the backend anytime and the UI will never notice. In practice, CopilotKit's interface layer gives several pre-implemented React building blocks that wire the agent directly into the app, like: - generative UI, so the agent renders real components instead of text - chat windows, sidebars, and popups, or a fully headless setup - shared state, so the agent and app stay in sync - human-in-the-loop approvals, where the agent waits before acting - persistent threads that store the whole session, including the agent-user interactions and generated UI, not just text And because that full history is captured, those interactions can feed a self-learning layer that also improves the agent from real usage over time. The interface layer that Anthropic spent years engineering in-house is now literally available to any developer/team. CopilotKit is open-source with 30k+ GitHub stars, and AG-UI, the protocol underneath, is already supported across every major agent framework: LangGraph, CrewAI, Mastra, Google ADK, and more. CopilotKit GitHub repo → (don't forget to star it ⭐ ) If you want to go deeper, I found a detailed breakdown by Shubham Saboo recently on the three Generative UI patterns, with implementation. Read it below.

Avi Chawla

461,550 views • 4 months ago

"User interfaces are largely going to go away. Because the agents speak English, or other languages. You can talk to them. You can say what you want. The UI can be generated. So I can say, generate me a set of buttons that allows me to solve this problem, and it's generated for you." - Eric Schmidt is the former CEO of Google. Today’s websites are designed for humans, with carefully crafted UIs. But we are probably moving towards UI-less web. automated bot traffic has already surpassed human activity on the web. with AI agents, this number will explode. In near future its very plausible that 90% or more of web traffic will be non-human. Imagine a web with no websites. All your favorite apps are now just databases, queried for information by agents that zip around on your behest. In a world primarily composed of bots, what happens to websites? Do agents learn to navigate them like a human? Do they go away entirely? 🤔 --- Video from 'Peter H. Diamandis' YT channel

"User interfaces are largely going to go away. Because the agents speak English, or other languages. You can talk to them. You can say what you want. The UI can be generated. So I can say, generate me a set of buttons that allows me to solve this problem, and it's generated for you." - Eric Schmidt is the former CEO of Google. Today’s websites are designed for humans, with carefully crafted UIs. But we are probably moving towards UI-less web. automated bot traffic has already surpassed human activity on the web. with AI agents, this number will explode. In near future its very plausible that 90% or more of web traffic will be non-human. Imagine a web with no websites. All your favorite apps are now just databases, queried for information by agents that zip around on your behest. In a world primarily composed of bots, what happens to websites? Do agents learn to navigate them like a human? Do they go away entirely? 🤔 --- Video from 'Peter H. Diamandis' YT channel

Rohan Paul

307,353 views • 28 days ago

Introducing the Next PROOF Launch! Macro launches on the 14th October 🚀 If you're thinking Macro is just another privacy browser, think again. Macro is your gateway to a robust privacy ecosystem, where your data, connections, and digital identity stay yours, always. Built from the ground up for both Web2 + Web3 users, Macro reimagines browsing with native privacy, intelligence, and security. No plugins, no telemetry, no tracking. It’s DeGoogled, private by default, and powered by an AI-native engine that protects and empowers the user every step of the way. Main Features (All built in. No plugins required) - Privacy Profiles: Distinct identities for work, degen, and personal use, each with separate cookies, wallets, and permissions. - Signing Sandbox: Intercepts connect & sign requests with plain-English decoding and policy checks. Undrainable by design. - Mesh P2P VPN: Peer-to-peer, verifiable routes with no centralized chokepoints. - Tab-Aware AI: Reads context, flags risks, and suggests safe actions, all locally. - Built-in E2EE Comms: Encrypted calls, messaging, and private file sharing Macro is building the foundation for private, intelligent, and secure browsing, all onchain. The future of browsing starts here. ⏰ Launch Date: Tuesday 14th October, 1PM UTC 🪙 Ticker: $MACRO ⛓️ Chain: ETH 🔔 Launch Alerts: ✨ Incubated by PROOF 📝 Socials and Docs Website: X: Macro Telegram: Docs: More project details on the way as we lead up to launch day, stay tuned 🔥

Introducing the Next PROOF Launch! Macro launches on the 14th October 🚀 If you're thinking Macro is just another privacy browser, think again. Macro is your gateway to a robust privacy ecosystem, where your data, connections, and digital identity stay yours, always. Built from the ground up for both Web2 + Web3 users, Macro reimagines browsing with native privacy, intelligence, and security. No plugins, no telemetry, no tracking. It’s DeGoogled, private by default, and powered by an AI-native engine that protects and empowers the user every step of the way. Main Features (All built in. No plugins required) - Privacy Profiles: Distinct identities for work, degen, and personal use, each with separate cookies, wallets, and permissions. - Signing Sandbox: Intercepts connect & sign requests with plain-English decoding and policy checks. Undrainable by design. - Mesh P2P VPN: Peer-to-peer, verifiable routes with no centralized chokepoints. - Tab-Aware AI: Reads context, flags risks, and suggests safe actions, all locally. - Built-in E2EE Comms: Encrypted calls, messaging, and private file sharing Macro is building the foundation for private, intelligent, and secure browsing, all onchain. The future of browsing starts here. ⏰ Launch Date: Tuesday 14th October, 1PM UTC 🪙 Ticker: $MACRO ⛓️ Chain: ETH 🔔 Launch Alerts: ✨ Incubated by PROOF 📝 Socials and Docs Website: X: Macro Telegram: Docs: More project details on the way as we lead up to launch day, stay tuned 🔥

PROOF

33,252 views • 1 year ago

Generative Rendering: Controllable 4D-Guided Video Generation with 2D Diffusion Models paper page: Traditional 3D content creation tools empower users to bring their imagination to life by giving them direct control over a scene's geometry, appearance, motion, and camera path. Creating computer-generated videos, however, is a tedious manual process, which can be automated by emerging text-to-video diffusion models. Despite great promise, video diffusion models are difficult to control, hindering a user to apply their own creativity rather than amplifying it. To address this challenge, we present a novel approach that combines the controllability of dynamic 3D meshes with the expressivity and editability of emerging diffusion models. For this purpose, our approach takes an animated, low-fidelity rendered mesh as input and injects the ground truth correspondence information obtained from the dynamic mesh into various stages of a pre-trained text-to-image generation model to output high-quality and temporally consistent frames. We demonstrate our approach on various examples where motion can be obtained by animating rigged assets or changing the camera path.

Generative Rendering: Controllable 4D-Guided Video Generation with 2D Diffusion Models paper page: Traditional 3D content creation tools empower users to bring their imagination to life by giving them direct control over a scene's geometry, appearance, motion, and camera path. Creating computer-generated videos, however, is a tedious manual process, which can be automated by emerging text-to-video diffusion models. Despite great promise, video diffusion models are difficult to control, hindering a user to apply their own creativity rather than amplifying it. To address this challenge, we present a novel approach that combines the controllability of dynamic 3D meshes with the expressivity and editability of emerging diffusion models. For this purpose, our approach takes an animated, low-fidelity rendered mesh as input and injects the ground truth correspondence information obtained from the dynamic mesh into various stages of a pre-trained text-to-image generation model to output high-quality and temporally consistent frames. We demonstrate our approach on various examples where motion can be obtained by animating rigged assets or changing the camera path.

AK

117,091 views • 2 years ago

Grok 4 prompt to generate the video's generative art: You are an expert P5.js developer with expertise in generative art, mathematics (vector fields, Perlin noise), and aesthetic design. Create a visually stunning, interactive particle flow field sketch that mimics ethereal, fluid dynamics with glowing trails and cosmic vibes. Key Features to Implement Exactly: Use P5.js via CDN (version 1.4.0). 1500 particles with random positions and sizes (1-4 pixels). Flow field via multi-layered Perlin noise: base noise + 0.5 * octave at 2x scale, using 3D noise with zOff incrementing by 0.002 per frame; noiseScale = 0.005. Particle physics: Vectors for pos, vel, acc; maxSpeed = 3; force mult 0.15. Dynamic colors: 5-color palette in HSV, baseHue = (frameCount * 0.1) % 360, each hue offset by 72 (pentadic), saturation 80, value 100, alpha 8; update in draw(). Interactivity: Mouse press attracts particles with normalized vector force, strength 0.05 * (1 / (dist + 1)). Aesthetics: Additive blendMode(ADD); noStroke; background fade fill(0,5) rect over canvas; variable sizes for depth. Utilities: Edge wrapping in Particle class; windowResized to resize canvas and reset background. Comments: Explain enhancements (time-based colors, mouse interaction, layered noise, trails), math (vector attraction, multi-octave noise). Step-by-Step Reasoning for Your Response: Analyze: Dissect user intent for aesthetics (glowing, dynamic, interactive) and math (noise layers, forces). Plan Code: setup() for init (canvas full window, particles, placeholders); draw() for fade, color update, zOff++, particle loop; Particle class with constructor, update (noise angle, force, mouse attract, physics), display, edges. Implement: Write modular, readable code with exact values; ensure performance. Verify: Mentally run: Particles flow smoothly, colors cycle, mouse pulls inversely, no errors on resize/edges. Enhance Output: Rate aesthetics/correctness (target 9.5/10); suggest tweaks (e.g., numParticles for perf). Output Structure: Full HTML with for P5.js code. Explanation: Brief on visuals/math/customizations/running.

Grok 4 prompt to generate the video's generative art: You are an expert P5.js developer with expertise in generative art, mathematics (vector fields, Perlin noise), and aesthetic design. Create a visually stunning, interactive particle flow field sketch that mimics ethereal, fluid dynamics with glowing trails and cosmic vibes. Key Features to Implement Exactly: Use P5.js via CDN (version 1.4.0). 1500 particles with random positions and sizes (1-4 pixels). Flow field via multi-layered Perlin noise: base noise + 0.5 * octave at 2x scale, using 3D noise with zOff incrementing by 0.002 per frame; noiseScale = 0.005. Particle physics: Vectors for pos, vel, acc; maxSpeed = 3; force mult 0.15. Dynamic colors: 5-color palette in HSV, baseHue = (frameCount * 0.1) % 360, each hue offset by 72 (pentadic), saturation 80, value 100, alpha 8; update in draw(). Interactivity: Mouse press attracts particles with normalized vector force, strength 0.05 * (1 / (dist + 1)). Aesthetics: Additive blendMode(ADD); noStroke; background fade fill(0,5) rect over canvas; variable sizes for depth. Utilities: Edge wrapping in Particle class; windowResized to resize canvas and reset background. Comments: Explain enhancements (time-based colors, mouse interaction, layered noise, trails), math (vector attraction, multi-octave noise). Step-by-Step Reasoning for Your Response: Analyze: Dissect user intent for aesthetics (glowing, dynamic, interactive) and math (noise layers, forces). Plan Code: setup() for init (canvas full window, particles, placeholders); draw() for fade, color update, zOff++, particle loop; Particle class with constructor, update (noise angle, force, mouse attract, physics), display, edges. Implement: Write modular, readable code with exact values; ensure performance. Verify: Mentally run: Particles flow smoothly, colors cycle, mouse pulls inversely, no errors on resize/edges. Enhance Output: Rate aesthetics/correctness (target 9.5/10); suggest tweaks (e.g., numParticles for perf). Output Structure: Full HTML with for P5.js code. Explanation: Brief on visuals/math/customizations/running.

tetsuo

44,518 views • 10 months ago

TEDRA Text-based Editing of Dynamic and Photoreal Actors discuss: Over the past years, significant progress has been made in creating photorealistic and drivable 3D avatars solely from videos of real humans. However, a core remaining challenge is the fine-grained and user-friendly editing of clothing styles by means of textual descriptions. To this end, we present TEDRA, the first method allowing text-based edits of an avatar, which maintains the avatar's high fidelity, space-time coherency, as well as dynamics, and enables skeletal pose and view control. We begin by training a model to create a controllable and high-fidelity digital replica of the real actor. Next, we personalize a pretrained generative diffusion model by fine-tuning it on various frames of the real character captured from different camera angles, ensuring the digital representation faithfully captures the dynamics and movements of the real person. This two-stage process lays the foundation for our approach to dynamic human avatar editing. Utilizing this personalized diffusion model, we modify the dynamic avatar based on a provided text prompt using our Personalized Normal Aligned Score Distillation Sampling (PNA-SDS) within a model-based guidance framework. Additionally, we propose a time step annealing strategy to ensure high-quality edits. Our results demonstrate a clear improvement over prior work in functionality and visual quality.

AK

17,302 views • 2 years ago

The DMT ecosystem is on the cusp of producing yet again another major breakthrough This time ushered in by Superfan.fan and his HIRO’s project AI and DMT are two technology primitives that when combined can produce a new class of digital asset with “lifelike” properties that are generated through Bitcoin block data We discuss this in an interview with Superfan 👇 Introducing HIRO’s Bitcoin’s First Generative AI Killer App Powered By DMT | w/ SuperFan | TBR #224 Superfan is building a next-generation suite of tools that enables creators to use generative AI in their UNAT scripts. This will be showcased by the upcoming HIRO’s launch on 🅼🆂🅲🆁🅸₿🅴 August 15th. HIRO’s is a collection of 4,032 dynamic characters that are responsive to non-arbitrary data patterns that occur on Bitcoin. The HIRO asset itself is an impressive demonstration of the high-fidelity output behind the technology stack being utilized to generate them. We speak with Superfan to understand better the technology and the practical use cases moving forward as he will open source. Also, his thoughts on community building by utilizing AI and the superpower ability it can introduce in metaverse construction. 🚀Sign up to receive our Ordinal Takeover Newsletter for weekly updates! Disclaimer: The views and opinions expressed by The Block Runner are for informational purposes only and do not constitute financial, investment, or other advice.

The DMT ecosystem is on the cusp of producing yet again another major breakthrough This time ushered in by Superfan.fan and his HIRO’s project AI and DMT are two technology primitives that when combined can produce a new class of digital asset with “lifelike” properties that are generated through Bitcoin block data We discuss this in an interview with Superfan 👇 Introducing HIRO’s Bitcoin’s First Generative AI Killer App Powered By DMT | w/ SuperFan | TBR #224 Superfan is building a next-generation suite of tools that enables creators to use generative AI in their UNAT scripts. This will be showcased by the upcoming HIRO’s launch on 🅼🆂🅲🆁🅸₿🅴 August 15th. HIRO’s is a collection of 4,032 dynamic characters that are responsive to non-arbitrary data patterns that occur on Bitcoin. The HIRO asset itself is an impressive demonstration of the high-fidelity output behind the technology stack being utilized to generate them. We speak with Superfan to understand better the technology and the practical use cases moving forward as he will open source. Also, his thoughts on community building by utilizing AI and the superpower ability it can introduce in metaverse construction. 🚀Sign up to receive our Ordinal Takeover Newsletter for weekly updates! Disclaimer: The views and opinions expressed by The Block Runner are for informational purposes only and do not constitute financial, investment, or other advice.

ᴛʜᴇ ʙʟᴏᴄᴋ ʀᴜɴɴᴇʀ Podcast 🟧

14,538 views • 2 years ago