Computing Life

Many people are asking: "Will AI replace me?"

But a more pertinent question is: "If I had ten AI team members right now, could I lead them effectively?"

From my experience, most people still view AI as just a tool. They focus on crafting prompts, optimizing outputs, and complaining about hallucinations. What concerns me more is how to transform AI into my second brain and executive center.

My favorite analogy is this: AI is like the steam engine during the Industrial Revolution. Before the steam engine, all production revolved around human power—we competed based on who could row faster or whose tools were better. But once the steam engine arrived, no amount of human effort could match the machine. The crucial skills shifted from "how to row faster" to "how to fuel the steam engine," "how to design propellers," and "how to coordinate the entire vessel efficiently." AI is similar: it's not just a faster screwdriver, but a fundamentally new power system compelling us to change our way of thinking.

In this article, I want to show you how someone who truly leverages AI thinks, deploys it, and reconstructs the future.

What is an Agent, Really? More Than Just AI That Does Tasks

Let's first break down the term: Agent.

This word has become popular recently, but it's often misunderstood. Many people hear "Agent" and think of "a small AI tool that completes a specific task," like an automated chatbot for ordering food, a coding assistant, or a plugin that summarizes meeting notes.

In my view, these aren't true Agents. At best, they are automation scripts or embodied interfaces.

So, what qualifies as a true Agent? I believe it needs to meet three essential criteria:

1. An Agent must be able to use tools. It shouldn't be limited to a single task but must combine multiple capabilities to achieve goals. For instance, it should be able to search the web, use a calculator, run code, scrape web pages, call third-party APIs, and more. You can't expect an AI that only recites answers to solve real-world problems.
2. An Agent must make autonomous decisions. You shouldn't have to guide it step-by-step. Given a goal, it must be able to think for itself: "What should I check first? What's the next step after that? Do I need to change my approach?" It must define its own strategy, break down tasks, and prioritize.
3. An Agent must engage in multi-round dynamic decision-making, not follow a fixed process. This point is particularly easy to overlook. Many so-called AI automation flows are just fixed logic stitched together with if-else statements. A true Agent should dynamically adjust its subsequent plans based on the results of previous steps, potentially even terminating or redefining the original goal.

Tool use is the foundation, autonomous decision-making is the brain, and multi-round iteration is the soul. Lacking any of these makes it merely an advanced script, not a true intelligent entity.

Think of it this way: An Agent isn't just a sophisticated flowchart; it's an executor with a mind of its own. Understanding this distinction is crucial because it determines whether we are merely using AI or commanding a digital employee with rudimentary autonomy.

Once you apply these three criteria, you'll realize that most "Agent" products on the market haven't truly crossed this threshold. It's like when the steam engine first appeared, many were still competing on who could row faster, ignoring that the power system itself had changed. The advent of Agents requires us not just to optimize old tools but to learn how to operate this new steam engine. But once you cross this mental threshold, the world looks different.

So, having understood what a true Agent is, how can we apply them in practice?

My Three Favorite Agent Types: Coach, Secretary, and Partner

Personifying Agents into these three roles isn't arbitrary; it's based on efficient collaboration patterns I've identified through extensive practice. This framework helps you quickly determine which AI persona is best suited for a given problem.

I've used numerous Agent products and built some myself. I've found that the Agents that truly work well and integrate seamlessly into daily life and workflows often fall into three roles, each indispensable:

Type 1: The Coach Agent

The core value of this type of Agent isn't doing the work for you, but helping you think clearly.

For example, when I use tools like o3, OpenAI's Deep Research, or similar platforms, my common use case isn't "Help me find this information," but rather, "Let me explain my problem, and help me map out the underlying structure."

I used this approach when buying a car. I faced various choices: how to allocate my budget? What were my family's real needs? What factors to consider? Should I opt for an electric vehicle? Instead of directly asking "Which car should I buy?", I asked the Agent to help me break down the decision structure, align the dimensions, and guide me through the trade-offs. In such scenarios, it acts more like a coach skilled in structured thinking than a mere knowledge base retriever.

The keyword is: Cognitive Companionship. Its value lies not just in whether its answers are correct, but in its ability to push me forward: organizing thoughts, pointing out blind spots, and finding structure amidst information chaos. It doesn't make decisions for me; it makes me a better decision-maker.

The core deliverable is cognitive clarity.

Type 2: The Secretary Agent

This type of Agent is key to freeing up my hands in daily life.

For instance, I use tools like Manus (or similar) to automatically generate a bedtime story for my daughter every day. The input might be that she refused to eat today, and I want the story, a rewritten version of Snow White, to subtly incorporate educational concepts. The output is an audio story with synthesized voice. The Agent writes the text and calls a TTS tool to generate the audio. I don't even need to record it myself; I just play it before bedtime.

Another example: I recently needed to visualize the historical stock trends of two companies. Traditionally, this would involve opening a coding environment, loading data, plotting... Now, I just state my intent in one sentence, and the Agent automatically fetches the data, generates the chart, and provides a summary.

The keyword is: Frictionless Execution. A Secretary Agent takes your intent and delivers the result. It doesn't need complex reasoning abilities, but its execution must be reliable, and it needs to operate across different systems and interfaces.

The core deliverable is seamless execution capability.

Type 3: The Partner Agent

This is the type I use most often as an engineer.

My work often involves complex tasks that aren't simple decompositions but require architectural design, module collaboration, and iterative development. In these situations, I tend not to use hands-off products like Manus or Devin. Instead, I use tools like Cursor or Copilot.

This is because I don't need the Agent to "write all the code for me." I need it to act like a coding partner with extremely fast typing speed and an exceptional memory. I explain the logic, and it helps me try out code; I adjust a module, and it automatically handles the dependencies. Crucially, it allows me to intervene at every step.

The keyword is: Deep Collaboration. In this scenario, the Agent is no longer a servant but a collaborator. We build together—I set the strategy, it executes, but I can oversee and replace every piece.

The core deliverable is a co-creation accelerator.

Different Agent types suit different problem scenarios. Mastering the switching and combination of these three roles is the first step towards becoming an effective AI commander. These three Agents form my superpower outsourcing team in the AI era.

However, building and commanding this team hasn't been smooth sailing. Early AI capabilities left me quite disappointed, but recent developments have impressed me significantly.

The AI I Once Criticized Now Silences Me

AI is evolving at a staggering pace. Three major flaws that deeply frustrated me just months ago are now being rectified at a visible speed, even making me reconsider my past judgments.

First, Clumsy Tool Invocation

This was perhaps my earliest point of dissatisfaction. ChatGPT had built-in Python, internet access, and plugin capabilities, yet when tasked with a job requiring multi-step tool coordination, it would often get lost. It was like a tailor equipped with scissors but unable to use them effectively—tools present, but the mind disconnected.

Then came o3. I was surprised to find that many of the previously clumsy scenarios were handled much more smoothly. Tasks that failed before could now succeed with o3. What silenced my criticism wasn't its ability to perform monumental tasks, but that it started acting like someone who actually knew how to get work done.

Second, AI Writing Had That Distinct "AI Flavor"

Previously, when I used AI to assist with writing, the output always felt artificial: sentences were overly polished, emotions were flat, and content seemed forced. Even DeepSeek, despite its significant improvements in Chinese generation, still read like marketing copy if you consumed enough of it.

However, my recent trials with GPT-4.1 and Gemini 2.5 Pro revealed a shift towards more natural output. The language now has pauses, the thought process shows selectivity, and the writing dares to leave things unsaid. There were moments I felt its writing was clearer and more insightful than many human writers. My experience shifted from "always needing to revise half of it" to "often usable as is"—a monumental change.

Third, Context Windows Were Too Small or Too Expensive

My most frequent use case for AI involves structured thinking, often requiring prompts exceeding hundreds of thousands of tokens. Previously, this was either impossible due to context limits or prohibitively expensive (early long-context models lacked effective caching).

It wasn't until GPT-4.1 introduced its 1M token window with optimized pricing that I felt this bottleneck truly starting to ease. From a practical, cost-effective standpoint, it became the first flagship model allowing me to consistently engage in million-token level interactions.

In summary:

I used to complain that AI had all the tools but lacked the connective thinking. Now, I see it starting to grasp human nuances. This isn't just a quantitative leap; it's a qualitative transformation. AI is slowly but surely evolving from a command executor towards a collaborative thinker, fundamentally altering the logic of our interaction with it.

Of course, this doesn't mean all problems are solved. While core AI capabilities are advancing rapidly, translating these capabilities into genuinely useful products integrated into existing workflows still faces numerous challenges.

But AI Products Still Have Three Frustrating Aspects

AI is evolving, but human pitfalls remain numerous. Particularly at the levels of product, design, and social systems, I still grapple with three unresolved pain points.

Instruction Following Remains a Mystery

Modern AI can generate images, write essays, and code, but ask it to simply avoid verbosity—sometimes it just can't, often to a comical degree.

I once tasked GPT-4.1 with writing the first three chapters of a draft. It did a decent job but couldn't restrain itself from adding superfluous remarks like "To be continued..." at the end. Modifying the prompt merely resulted in different phrasing; limiting the length led to sneakily compressed sentences. I ultimately resorted to a hack: forcing it to include specific keywords and then programmatically deleting them.

This lack of control over basic instructions highlights a persistent gap in current AI's understanding of constraints and intent. We've taught it to write poetry, but not how to be concise.

Many Products are "AI for AI's Sake," Failing to Solve Real Problems

I've seen countless AI product demos proudly showcasing capabilities like, "We can book your flights!" followed by simulated conversations that fill out forms and handle payments.

While technically impressive, this often misses the point entirely. The real pain point in booking flights lies in the decision-making: is it better to leave a day earlier or later? Is the convenience of a pricier hotel worth the cost? These are judgment calls, not procedural tasks. Automating form-filling saves a minute; helping me clarify trade-offs could save three hours.

Too many products are obsessed with flexing AI's technical muscles while ignoring the user's most pressing needs. This is classic "hammer searching for a nail" thinking, rather than being driven by user value. AI products shouldn't exist merely to showcase AI; they must genuinely address human challenges.

Human Society Wasn't Designed for AI, Leaving "Dark Information" Inaccessible

This point borders on the philosophical but is intensely practical. Many crucial decisions aren't made within documented processes but emerge from conversations in cafes, over dinner tables, within chat groups, or even during casual hallway encounters. This unstructured, unrecorded knowledge is what I often refer to as "tribal knowledge."

AI simply cannot access this domain. You can't ask clients to wear microphones during meals to feed recordings to an AI for analysis. This reveals a stark reality: the boundaries of AI intelligence are currently confined to the realm of explicit data. The true lubricants of human social function—the implicit, unstructured "dark information"—remain almost entirely beyond AI's reach.

This isn't a failing of AI itself, but a reflection that we haven't yet built an AI-friendly society.

In Short: While tools leap forward and models awaken, the lag in product thinking and the barriers of the real world remain significant obstacles to realizing AI's full value. AI is a new species we've created, but it's still forced to operate by the old world's rules.

This gap between AI's potential and its current application leads to a critical question about business competition: Among the numerous Agent products, where does the true competitive advantage lie? Is it merely a stronger model? I believe not.

The Moat for Agents Isn't Smarts, It's Rapport

Regarding the competitiveness of Agent products, the industry often overly emphasizes model capabilities. However, based on my judgment, this focus might be strategically misguided. The true moat isn't built from smarter models, but from the rapport (or Accord) developed over time with users and organizations.

What does this mean?

Consider this example: Suppose I'm an internal user at Meta, and I ask Manus to create a company introduction presentation. The first version uses green as the primary color. I correct it: "No, we use blue." Manus remembers. The next time I ask for a presentation, it automatically uses blue.

This seems simple, right? But it's the beginning of organizational-level rapport. The Agent learns our style preferences, compliance requirements, what the boss dislikes, which terms are taboo, how files should be named uniformly... None of this is generic LLM knowledge; it's the organization's muscle memory.

As this memory accumulates, you get a very real sense that it's less like an AI and more like a long-term colleague.

That's the power of rapport.

No matter how advanced Devin is, or how new the model—even if GPT-5 arrives—if it doesn't understand our organization's internal context (like the fact that our boss, Jim, particularly dislikes the word "innovation"), it will never be as valuable as a slightly less intelligent Agent that understands you.

This rapport is essentially the Agent's deep adaptation and internalization of its specific environment (personal preferences, team norms, organizational culture). It represents a highly customized, contextual intelligence that cannot be easily replicated by general-purpose models.

Therefore, the core design challenge for Agent products is how to efficiently capture, store, and apply this rapport data, evolving the Agent from a generic tool into a dedicated partner. Products that achieve this will build an insurmountable advantage in user stickiness and long-term value. This, I believe, is where the real competition lies for Agent products—where true value differentiation can be established.

If one day, users start actively feeding your product data that isn't directly related to task completion—like pasting unrelated notes or uploading materials that "might be useful later"—it's actually a very strong signal. It means they've started expecting the product to deliver some kind of "surprise," trusting that even if the information isn't useful now, it might help at some point in the future. This behavior reflects deep trust in data fusion and personalization. Reaching this stage means your product has already won a significant part of the battle.

However, cultivating this rapport is crucial, but to fully unleash AI's potential, we need to think further: instead of making AI adapt to our existing world designed for humans, perhaps we should reshape the world to better suit AI.

We Need an AI-Native World, Not Just Smarter AI

At this point, we must move beyond the framework of simply using AI effectively and consider a grander question: How should we redesign our world to make it more suitable for AI to operate efficiently? This is the key to unlocking the true potential of the intelligent era.

Here's a good example of an AI-native (or perhaps more accurately, AI-friendly) product: Cursor. Previously, when writing prompts or using AI assistance, we often had to manually piece together context from fragmented sources—checking documentation, searching code, finding relevant snippets. The process was disjointed because the environment wasn't inherently AI-friendly. Cursor's approach, however, allows the LLM to seamlessly fetch and integrate various contexts within your workspace—code, docs, search results—all automatically feeding into the context window. This approach makes the toolchain more AI-native to a degree: Cursor does a lot behind the scenes to make it easier for the AI to grasp the full context, thus enabling it to work more effectively.

Of course, Cursor is just one simple example. Historically, similar, yet far broader and deeper, changes have genuinely occurred.

When the electrical revolution began, factories initially just replaced the central steam engine driving the main shaft with a large electric motor, using the same system of belts and driveshafts to distribute power. This wasn't a true electrical revolution; it was merely electricity substituting for steam.

The real revolution occurred when they realized: "Since electricity can be transmitted, why not install a small electric motor directly at each workstation?" A wire runs to the station, and a small motor powers the local task. The true explosion of the electrical revolution stemmed not from bigger motors, but from the disruptive concept of distributed power. What we need today is the equivalent: a distributed intelligence architecture for the AI era.

Currently, we often operate in the "main shaft" phase of the AI era. We use AI to interface with legacy systems, polish text, generate flowcharts, and act as customer service bots. However, our entire information architecture, process logic, and permission models are still designed primarily for humans.

We haven't yet truly asked ourselves: If we were to design organizations, documentation, protocols, and processes from scratch, assuming AI is the primary workforce, what would that look like?

As I mentioned earlier—today's code documentation is designed for human readers: paginated, hyperlinked, fragmented. But AI doesn't need pagination; it prefers an all-in-one format. It isn't bothered by long code blocks; in fact, it often benefits from more context. Therefore, truly AI-native documentation might be code-dense, fully context-integrated, and parametrically consistent.

This implies a need to systematically redesign how we organize information, structure workflows, define collaboration protocols, and even architect our organizations, shifting from a human-centric approach to a human-AI collaboration-first model. This is a daunting but critically important task, promising exponential leaps in productivity.

Imagine a world where API documentation is inherently readable and writable by AI, where meeting minutes automatically translate into executable task flows, where knowledge bases proactively push relevant context to the Agents that need it... That is the vision of an AI-native future.

Achieving such an AI-native future requires more than just technological breakthroughs; it demands that we transform our roles from passive AI users into proactive AI leaders.

Conclusion: Stop Asking if AI Will Replace You, Ask if You Can Lead AI

The fundamental question isn't "Will AI replace you?" but rather, "Have you become the person capable of integrating, managing, and inspiring AI?"

Some will be swept away by the AI wave; others will assemble AI into fleets, chart the course, and command the rhythm.

The era of tools is ending. The era of the commander has begun.