The most useful agents are not the ones that simply complete more tasks. They are the ones that know what they are doing, why it matters, what could go wrong, and when not to act.

That is the work I have been doing recently: turning agents from task executors into systems with situational awareness.

A task agent asks, “What did the user ask me to do?”

A situationally aware agent asks a better set of questions:

  • What is the state of the world right now?
  • What has already happened in this thread, inbox, calendar, or pipeline?
  • What would be risky, premature, stale, duplicative, or irreversible?
  • What should be drafted, and what should require explicit approval?
  • What downstream state needs to be updated so the next agent does not start blind?

That difference sounds subtle, but it changes the shape of the product.

The real problem is not task completion

Most agent demos make the unit of work look simple:

  • read this email
  • reply to this recruiter
  • schedule this meeting
  • summarize this transcript
  • publish this post
  • update this pipeline

Each of those tasks is easy to describe. The hard part is the context around the task.

A recruiter message is not just text to answer. It may be stale. It may refer to a role that has already been rejected. It may require a resume that should not be sent until the role is qualified. It may conflict with another process. It may require a relationship-first reply instead of a transactional one.

A calendar invitation is not just an open slot. It may hide a conflict. It may overlap with a more important meeting. It may need a narrow replacement window. It may need a prep document before the meeting is useful.

A blog post is not just a draft. It may need to match the existing positioning, avoid overclaiming, separate operational site updates from editorial work, and stay unpublished until explicitly approved.

The task is only the visible part. The judgment lives in the surrounding state.

Mature agents need negative capability

A lot of agent work focuses on getting the model to do more.

But the more important capability is often knowing what not to do.

A mature agent should know:

  • do not answer a stale notification
  • do not confirm a meeting with a hidden conflict
  • do not share a resume before qualifying the role
  • do not publish or send something just because a draft exists
  • do not ask for another referral when the relationship has already been used
  • do not treat a generic notification as actionable without checking the underlying message

This is more mature than “agent does task.”

It is closer to an operating discipline: act when the state is clear, draft when the action is reversible, escalate when the decision belongs to the human, and remember the result so the next interaction starts from the right place.

The pipeline is the product surface

Recent work has made one thing obvious: the pipeline is not an admin artifact. It is the product surface.

For career work, the pipeline is not just a list of companies. It is the shared memory that tells the agent:

  • who the person is
  • how warm the relationship is
  • whether a reply has already been drafted
  • what stage the process is in
  • what resume or positioning should be used
  • whether the next action is outreach, scheduling, prep, follow-up, or waiting
  • what should not be repeated

Without that pipeline, every agent turn is a fresh hallucination risk.

With it, the agent can behave more like a steward. It can notice that a new LinkedIn message upgrades an existing opportunity instead of creating a duplicate. It can avoid re-opening a settled thread. It can draft the next reply in the right tone. It can keep the user from having to restate the same constraints every day.

That is the broader pattern: useful agents need durable state, not just longer prompts.

Calendar awareness changes everything

Scheduling is a good example because the failure modes are concrete.

Scheduling is not just availability. It is:

  • checking the actual calendar
  • detecting conflicts
  • understanding which meeting matters more
  • suggesting a narrow replacement window
  • knowing whether prep is needed before the meeting
  • avoiding confirmation until the user has approved the exact plan

This turns a simple scheduling agent into something closer to an executive assistant.

The agent is no longer just saying, “You are free at 2.” It is saying, “There is a conflict at 2, the other meeting appears higher priority, here are two replacement windows, and I drafted the reply but did not send it.”

That difference is the product.

Drafts are not actions

One of the most important boundaries is separating drafting from doing.

Drafting is cheap and reversible. Sending is not. Publishing is not. Scheduling is not. Accepting or declining an invitation is not.

That means an agent can move quickly while still preserving human control:

  • draft the reply, but do not send it
  • prepare the meeting document, but do not assume the meeting is confirmed
  • write the article, but do not publish it
  • update the pipeline, but preserve the evidence trail
  • surface the recommended next action, but let the human choose when it affects another person

This is not a limitation. It is how trust compounds.

The user can let the system do more because the system has clear boundaries.

The work is broader than career operations

The recent career workflows are a useful testbed because they combine everything agents struggle with:

  • ambiguous natural language
  • high-context relationships
  • multiple communication channels
  • external deadlines
  • private information
  • irreversible social actions
  • changing priorities
  • long-lived state

But the pattern is not career-specific.

Any serious agentic workflow needs the same ingredients:

  • a durable model of the domain
  • a way to distinguish drafts from committed actions
  • a memory of prior decisions
  • a source of truth for current state
  • explicit approval gates for irreversible actions
  • auditability when the agent changes shared state

That applies to sales, recruiting, customer success, operations, research, personal admin, and software work.

The details change. The product principle does not.

Agents should make the next action obvious

The goal is not for the agent to sound smart. The goal is for the agent to reduce ambiguity.

A good agent should leave the user with a clear next action:

  • approve this exact reply
  • choose between these two times
  • review this draft
  • ignore this notification
  • qualify this role before sending a resume
  • update the right source of truth so the next agent sees the same state

That is what situational awareness buys you. It turns a pile of messages, drafts, calendar events, and notes into a small number of safe next moves.

Conclusion

The next generation of agents will not be judged only by how many tools they can call.

They will be judged by whether they understand the situation well enough to act safely.

That means knowing the user’s preferences, the current state of the world, the history of the workflow, the boundary between drafts and actions, and the difference between helpful momentum and premature execution.

The agent should not just do the task.

It should know what the task means.