Latest / AI Fire Daily / #578 Neil: Grok Agent Is Starting To Feel Like A Real AI Teammate

Transcript

#578 Neil: Grok Agent Is Starting To Feel Like A Real AI Teammate · AI Fire Daily

• 0:00
  It's beat. Right now, your laptop is probably
• 0:04
  closed. Most likely, yeah. But inside it, an
• 0:07
  AI isn't just answering a simple question. It
• 0:11
  is actively moving a digital mouse. It really
• 0:14
  is. It's wild to think about. It's clicking through
• 0:17
  your messy spreadsheets. It's even messaging
• 0:19
  your coworkers on Slack. We are officially past
• 0:22
  the era of the simple chat bot. We really are.
• 0:25
  It's a completely new paradigm. Welcome to the
• 0:27
  Deep Drive, everyone. Today, we are exploring
• 0:30
  XAI's brand new Grok agent. Right, which officially
• 0:34
  goes by the name Grokbot. It is a massive shift
• 0:36
  in how we work. Definitely. And we have a packed
• 0:39
  roadmap for you today. We really do. We're going
• 0:41
  to look at setting up your first agent. Then
• 0:43
  we'll see how multiple agents actually collaborate
• 0:45
  together. The multi -agent stuff is fascinating.
• 0:47
  Oh, it's crazy. We'll also explore some intense
• 0:50
  real -world developer workflows. And finally,
• 0:53
  we will tackle the serious $200 monthly price
• 0:57
  barrier. Which is steep? Yeah, that price tag
• 0:59
  really determines if this tool is actually for
• 1:01
  you. Sweet. Let's start by unpacking the core
• 1:05
  concept here. To understand how this AI actually
• 1:08
  does the work, we must look at how it learns.
• 1:12
  How does it learn your highly specific daily
• 1:14
  workflow? Grok Agent is not a passive text box.
• 1:19
  It's an active AI teammate. Exactly. It uses
• 1:22
  your actual web apps. It literally operates its
• 1:25
  own virtual computer in the background. That
• 1:28
  virtual computer detail is, well, it's absolutely
• 1:31
  crucial. Context is everything. when you're working
• 1:33
  on complex projects. You can give each Grok agent
• 1:36
  a very specific job title. You don't start from
• 1:39
  zero every single morning. Because it remembers
• 1:41
  exactly what you were doing yesterday. Right.
• 1:43
  Which brings us to the standout feature. It's
• 1:46
  called teach a task. This completely changes
• 1:48
  the user experience. You don't write massive
• 1:51
  complex text prompts anymore. Thank goodness.
• 1:53
  Seriously, you just perform your standard browser
• 1:56
  workflow one time. The agent simply sits there
• 1:59
  and watches what you do. B, this is such a fascinating
• 2:02
  psychological shift. It's like training a new
• 2:04
  intern by having them look over your shoulder
• 2:06
  instead of handing them a dense manual. That
• 2:08
  is the perfect analogy. You just show them the
• 2:10
  ropes naturally. I mean, I have to make a vulnerable
• 2:13
  admission here. Oh, yeah. Yeah. I still wrestle
• 2:16
  with prompt drift myself when I try to text command
• 2:19
  complex tasks. Writing a perfectly structured
• 2:22
  prompt is absolutely exhausting. Right. And it
• 2:25
  is incredibly frustrating for most users. You
• 2:28
  write a perfect detailed prompt. on a Tuesday.
• 2:31
  By Thursday, the underlying model interprets
• 2:34
  it slightly differently. And the output just
• 2:36
  breaks. Exactly. Visual demonstration removes
• 2:39
  that entire layer of translation error. You show
• 2:42
  it the action, it learns the exact behavior.
• 2:44
  But we need to look at the mechanics behind that.
• 2:46
  Okay. If I just show it my screen... How does
• 2:49
  it really know what I'm doing? I have a probing
• 2:52
  question about accuracy here. Shoot. How accurately
• 2:55
  does it capture the exact steps without missing
• 2:57
  the nuanced details? Well, it relies heavily
• 3:00
  on computer vision and DOM parsing. Wait, let's
• 3:02
  unpack that for a second. DOM parsing. Right.
• 3:04
  Let me explain how that actually works. It's
• 3:06
  not just looking at a flat picture of your screen.
• 3:08
  OK. DOM parsing means it reads the underlying
• 3:11
  structural code of the web page. It looks at
• 3:13
  the actual digital skeleton. Ah, so it sees the
• 3:16
  code behind the visual layout. Yes. So when you
• 3:19
  click a blue submit button, it knows exactly
• 3:21
  what that button represents in the system. That
• 3:23
  makes sense. It maps the visual interface to
• 3:26
  the actual code. Grok Agent then turns this observation
• 3:29
  into a reusable skill. So it builds reusable
• 3:33
  skills directly from your actions. Yes, it learns
• 3:35
  by doing. Though XAI strongly recommends testing
• 3:40
  this save skill manually. Right. Trust but verify.
• 3:44
  Exactly. You should watch it perform the task
• 3:46
  once before relying on it completely. That makes
• 3:49
  perfect sense. So if I can teach it to do this
• 3:53
  one thing perfectly by just watching me, what
• 3:56
  happens when I need it done 500 times by tomorrow
• 3:59
  morning? Does it just sit there waiting for me
• 4:01
  to hit a button? Not at all. That is where we
• 4:03
  get into the scaling phase. Okay. Once it learns
• 4:05
  a task, You use routines. Routines let you run
• 4:08
  these saved workflows on specific schedules.
• 4:10
  Like setting an alarm clock for your tasks. Exactly.
• 4:13
  You could have it check a specific data source
• 4:15
  every single morning at 8 a .m. Or you can use
• 4:18
  trigger events instead of schedules. Give me
• 4:20
  an example of a trigger event. Well... You could
• 4:23
  have the agent watch your Slack channels. OK.
• 4:26
  You set a specific condition, like waiting for
• 4:28
  a message that says urgent bug. Oh. When that
• 4:32
  message appears, the agent wakes up and executes
• 4:35
  its routine. He's like, silence. The fascinating
• 4:38
  part is the background execution. This all happens
• 4:41
  even when your own laptop is closed. It's a huge
• 4:45
  architectural departure from older tools. You
• 4:48
  don't need to leave your browser open. You don't
• 4:50
  need to keep your machine running hot overnight.
• 4:52
  Because the agent lives on its own cloud computer.
• 4:55
  Precisely. But the system gets even crazier than
• 4:57
  that. How so? You can put several different Grok
• 5:00
  agents into one single thread. Really? Yeah.
• 5:03
  They can run the routines in parallel. They can
• 5:05
  actually message each other. They hand off complex
• 5:08
  work seamlessly. I am trying to picture this
• 5:11
  in my own day -to -day. Sure. If I am using three
• 5:13
  different apps to put together a weekly report,
• 5:16
  how do these agents actually pass the baton to
• 5:18
  one another without dropping the data? Think
• 5:20
  of it kind of like a virtual digital assemble
• 5:22
  line. OK. One agent acts purely as the data researcher.
• 5:27
  It goes out and collects source material from
• 5:29
  the web. It organizes that raw data into a clean
• 5:32
  format. Then it passes that raw data to a second
• 5:36
  agent. The second agent is waiting in the same
• 5:38
  thread. Right. The second agent is specifically
• 5:41
  prompted to be the writer. Ah. It takes the researcher's
• 5:45
  data and prepares the final report. They coordinate
• 5:48
  this entire workflow entirely on their own. Two
• 5:51
  -sex silence? That is profoundly weird to think
• 5:55
  about. Your digital clones are having a meeting
• 5:58
  without you. Whoa. Imagine multiple agents messaging
• 6:02
  each other to finish your project while your
• 6:04
  phone is in your pocket. It feels like absolute
• 6:06
  science fiction. It really has. But that raises
• 6:08
  a very practical question about device reliance.
• 6:11
  Okay. What happens if my phone dies or I lose
• 6:14
  connection during a massive multi -agent task?
• 6:16
  The task doesn't care about your local device
• 6:18
  at all. Really? Like we said, the agents live
• 6:21
  on the cloud computer. Your phone or laptop is
• 6:24
  merely a viewing window. Ah, I see. If your phone
• 6:27
  battery dies on a flight, The agents just keep
• 6:30
  working. Work continues safely in the cloud,
• 6:33
  completely uninterrupted. Exactly. You just log
• 6:35
  back into the iOS app later. Right. You can monitor
• 6:37
  their progress. You can review the results or
• 6:40
  approve steps right from your iPhone when you
• 6:42
  land. Beat theory is great. I love talking about
• 6:45
  digital assembly lines. It's fun, yeah. But we
• 6:48
  need to connect this to the bigger picture. We
• 6:50
  have to look at how people are actually using
• 6:53
  this right now. The source material highlights
• 6:56
  some fascinating real -world developer workflows.
• 7:00
  Let's start with Balta's use case. That one really
• 7:03
  stood out to me. Balta's workflow is a perfect
• 7:06
  starting point. Yeah. He used Grokbot to actively
• 7:10
  listen to Slack channels. Okay. The agent was
• 7:13
  specifically looking to debug live software issues.
• 7:16
  Okay. It would find the bug reports. analyze
• 7:19
  them, and actually fix the code. He was essentially
• 7:22
  dog -fooding the product there. He used Grokbot
• 7:24
  while he was developing Grokbot itself. Yes,
• 7:27
  which is the ultimate stress test. This setup
• 7:29
  is ideal for small, fast -moving development
• 7:33
  teams. Bug reports usually live in chaotic internal
• 7:37
  Slack channels. Not true. Normally, a developer
• 7:40
  has to copy the error text. They move it to a
• 7:42
  separate coding window. The Grok agent just enters
• 7:46
  the Slack workflow directly. It acts like a real
• 7:48
  co -worker in the chat. Exactly. Then we have
• 7:50
  Peter Dedene's use case. This one focuses heavily
• 7:53
  on cross -app research. Yeah, he connected Notion,
• 7:56
  Linear, and Slack together. This is where the
• 7:59
  tool gets really powerful for non -engineers.
• 8:01
  For sure. Grok actively researched specific people
• 8:05
  and companies for him. Then it created customized
• 8:08
  LinkedIn messages and email drafts. And it wrote
• 8:11
  them in his actual voice. Right, because it had
• 8:13
  access to his previous communications. It did
• 8:15
  this without any manual copying and pasting.
• 8:18
  Which is huge. That is usually the biggest friction
• 8:20
  point in knowledge work. opening five different
• 8:22
  tabs, copying context from a Notion document,
• 8:25
  moving it over to a Slack message, losing your
• 8:27
  train of thought in the process. Yeah, exactly.
• 8:29
  Grokbot brings these disjointed steps into one
• 8:32
  unified workflow. It's a massive time saver for
• 8:36
  roles like sales or recruiting. You eliminate
• 8:39
  the busy work of moving data around. But the
• 8:41
  third example in our sources is even more intense.
• 8:44
  Oh, yeah. Thomas Grove focused entirely on heavy
• 8:47
  developer workflows. He connected Grokbot. directly
• 8:50
  with GitHub MCP. Yes. He allowed the bots to
• 8:54
  run commands from the CLI. Let's define that
• 8:57
  jargon really quickly. A text interface where
• 8:59
  you type commands directly to the computer. Perfect
• 9:02
  definition. So using that raw interface, Grokbot
• 9:06
  created a completely new software repository
• 9:09
  from scratch. Wow. It bypassed the graphical
• 9:12
  interface entirely. I have to push back here
• 9:14
  for a moment. OK, go ahead. Is this really a
• 9:17
  new paradigm? Or is this just another coding
• 9:19
  assistant with a fresh coat of paint? I see what
• 9:21
  you mean. We've had AI write code for a couple
• 9:24
  of years now. True, but it is absolutely not
• 9:26
  just a passive assistant. How so? An assistant
• 9:28
  gives you code in a static chat window. Then
• 9:32
  the human has to copy it. Right. The human has
• 9:34
  to paste it into the terminal. The human has
• 9:36
  to run it and check for errors. OK, I see the
• 9:38
  difference. Grokbot is an active participant
• 9:41
  in the systems your team already uses. It executes
• 9:44
  the actions itself. So it removes the human middleman
• 9:47
  from the loop? Yes. Let me ask about the developer
• 9:49
  limits, though. How far can it actually go in
• 9:52
  a live production environment? Right now, it
• 9:56
  has incredibly broad access if you granted the
• 9:59
  permissions. Through tools like GitHub MCP, it
• 10:03
  can interact with your code base directly. It
• 10:05
  can execute local scripts. It essentially acts
• 10:08
  like a junior developer who has been given terminal
• 10:11
  access. It runs actual terminal commands and
• 10:13
  creates entire repositories. Exactly. It takes
• 10:16
  a physical part in the actual development process.
• 10:19
  Amazing. It doesn't just suggest the work, it
• 10:21
  performs the work. Sponsor. Welcome back to the
• 10:24
  Deep Dive. We have been talking about digital
• 10:26
  assembly lines and agents writing their own code.
• 10:29
  Yeah, it's pretty wild stuff. This all sounds
• 10:31
  like absolute magic. But we need a serious reality
• 10:34
  check. We do. What is the actual cost here? Where
• 10:37
  does this system break down in practice? Well,
• 10:40
  it is still in an early stage of development.
• 10:41
  That's the first major limitation we need to
• 10:44
  acknowledge. Right. Features like Teach a Task
• 10:46
  are rolling out very gradually to users. Even
• 10:49
  if you sign up today, your account might not
• 10:51
  have everything yet. The experience will likely
• 10:53
  change quite a bit as XAI pushes updates. Definitely.
• 10:57
  But let's talk about the big barrier to entry.
• 11:00
  The pricing model is incredibly aggressive. It
• 11:03
  really is. You can get a one -week free trial
• 11:06
  to test it out. OK. But you must provide a credit
• 11:09
  card upfront. After that trial ends, it is $200
• 11:13
  per month for the Ultra tier. Wow. Alternatively,
• 11:18
  you can access it via a Super Grok Heavy subscription.
• 11:21
  I really have to reflect on that $200 price tag.
• 11:24
  It's a lot. Casual users simply won't find the
• 11:27
  return on investment here. If you just want a
• 11:29
  chat bot to help you write occasional emails,
• 11:31
  this is a terrible deal. Yeah, totally. This
• 11:34
  pricing makes it a purely pro -tier tool. Completely
• 11:37
  agree. You need to have heavy, repetitive daily
• 11:40
  workflows to justify that monthly cost. Make
• 11:42
  the tool pay for itself, basically. Exactly.
• 11:46
  The compute power required to run virtual background
• 11:48
  computers is massive. Founders, developers, and
• 11:52
  heavy automators will absolutely love it. The
• 11:55
  casual user should definitely stay away. Stay
• 11:57
  far away, yeah. There is another significant
• 11:59
  limitation regarding the AI models themselves.
• 12:02
  Right. The sources note that you do not get full
• 12:04
  model control. That's true. Grok manages the
• 12:08
  model routing entirely for you in the background.
• 12:11
  Okay. It automatically chooses what it thinks
• 12:13
  is the best model for the specific task. This
• 12:17
  keeps the experience incredibly simple for the
• 12:19
  user. But advanced users might find this frustrating.
• 12:22
  Power users usually want to pick their specific
• 12:24
  tool. Oh, for sure. Like, can I force it to use
• 12:27
  a specific model for coding tasks if I know it
• 12:30
  performs better? You might think you could, but
• 12:33
  no. You have to trust its internal routing logic
• 12:35
  completely. No, Grok automatically handles all
• 12:38
  model routing for you. Exactly. You cannot override
• 12:40
  it. Two sec silence. That requires a massive
• 12:43
  amount of trust. It really does. Especially for
• 12:45
  complex developer tasks where specific models
• 12:48
  shine. What happens when the agent hits a security
• 12:51
  checkpoint? Does it just guess my password? That
• 12:54
  is a great question and thankfully no. Phew!
• 12:58
  There are strict manual approvals built into
• 13:00
  the system architecture. Okay. The agent will
• 13:03
  literally pause its workflow. It waits for you
• 13:06
  to intervene for sensitive actions. What qualifies
• 13:09
  as a sensitive action in this context? Entering
• 13:12
  passwords. Inputting two -factor authentication
• 13:14
  codes from your phone. Makes sense. Solving visual
• 13:17
  check DTCAs. Approving financial payment confirmations.
• 13:22
  Basically anything that requires a verified human
• 13:24
  to confirm intent. I actually think this is a
• 13:27
  fantastic limitation. GROK agents should absolutely
• 13:30
  not make every sensitive decision by itself.
• 13:33
  Right, and you should expect some complex workflows
• 13:35
  to pause naturally. So how does it notify you?
• 13:37
  You will get a push notification on your device.
• 13:39
  You review the specific step, you approve it
• 13:42
  manually, and the agent continues its work. It
• 13:45
  intentionally keeps a human in the loop for the
• 13:47
  critical moments. Exactly. It prevents the agent
• 13:50
  from going completely rogue with your credit
• 13:52
  card. Which is very important. Speed. Let's synthesize
• 13:56
  the overarching theme of these sources. We are
• 13:59
  officially moving away from AI as a passive chat
• 14:02
  window. We absolutely are. The era of endlessly
• 14:06
  copying and pasting from a text box is ending.
• 14:08
  We are moving rapidly toward AI as an active,
• 14:12
  persistent system. It takes concrete action across
• 14:15
  multiple applications. It lives and breathes
• 14:18
  on its own virtual computer. It fundamentally
• 14:20
  changes our relationship with the software we
• 14:22
  use every day. It does. You are no longer the
• 14:25
  one clicking the buttons. You become a manager
• 14:27
  of agents rather than a doer of tasks. That is
• 14:31
  exactly the shift. You teach the process one
• 14:33
  time. You automate the tedious repeated work.
• 14:36
  You let several agents share the heavy lifting
• 14:38
  while you focus on high level strategy. Which
• 14:41
  brings me to a final uncomfortable thought I
• 14:43
  want to leave you with. Okay, let's hear. If
• 14:45
  AI agents can now seamlessly handle multi -step
• 14:48
  research, if they can flawlessly manage cross
• 14:52
  -app data collection, if they can do basic debugging
• 14:55
  across all our internal tools, what happens to
• 14:58
  the entry -level human roles? It is a profound
• 15:00
  question for the entire tech industry. Historically,
• 15:05
  those exact manual tasks served as a necessary
• 15:08
  training ground. They did, yeah. It's how young
• 15:10
  professionals learned the intricate details of
• 15:12
  their industry. You learn by doing the boring,
• 15:15
  repetitive work. That's how everyone starts.
• 15:17
  If we automate all the junior -level busy work,
• 15:20
  where do the humans actually start learning now?
• 15:23
  The entire ladder of career progression might
• 15:26
  need to be completely rebuilt from the ground
• 15:28
  up. We highly encourage you to review your own
• 15:30
  daily routines this week. Definitely do that.
• 15:32
  Look at your repetitive manual tasks. Ask yourself
• 15:35
  if a background agent could eventually take them
• 15:37
  over. Thank you for joining us on this deep dive.
• 15:41
  Out to your own music.