Jensen Huang: Typing Is Dead. Directing Agents Is the New Job Description.

The October Berlin GTC keynote is the moment the story stopped being about the keyboard and became about the job. Jensen Huang declared the end of the traditional PC, and introduced RTX Spark as your personal agent, a digital companion that works for you instead of software you launch. The register of the announcement matters: he did not present a faster computer or a bigger screen, he presented a worker, and the difference between those two presentations is the whole change of the decade. In the same keynote, as The Register noted, he steered a robot duck by voice command, telling it to lie down, roll over, and nap. Hardware and human are being rearranged around a new relationship: the thing on your desk now takes direction instead of input.

The framing that does the most work is hire rather than use. Software you use requires you to perform steps: open, navigate, fill, click, arrange. A worker you hire requires something different: you say what you want, you set the boundaries, you accept or reject the work. The unit of the system changes from the app you reach for to the engagement you run, and that single change rewrites what most job descriptions assume about the computer. Most descriptions still say the quiet part out loud: proficiency in this tool, proficiency in that environment. In an agent workforce the analogous line is not a tool name, it is a track record of clear briefs and honest reviews.

GTC 2026 pushed the same line to the organizational level: every company needs an agentic strategy, and this is the new computer. If the strategy is agentic, the operating layer of the company is no longer a set of interfaces and permissions, it is a workforce of briefs, reviews, and handoffs. Companies, and the people inside them, will differ mostly in how well they brief, not in how fast they type. The skill trained by years of software proficiency gets replaced by a skill that was never on a syllabus: specifying clearly enough that a capable, quick worker knows exactly what is wanted without asking twice.

For an individual, the announcement is best read as a job-title prediction. If the computer is a colleague you hire, then the person who used to be described as the one who uses the software is now better described as the one who directs the agents. That description is not decoration. What you write in it determines what you build your day around, and what gets reviewed by the people above you. A job description is the most honest forecast of a role's future, which is why the rewrite is worth doing before the offer letter arrives rather than after.

Using software is operating: the human performs the sequence, and the tool is an instrument. You do not manage a text editor, you operate it, and the quality of the outcome is limited by how well you perform the steps. Hiring software is managing: you specify the work, you delegate, you review. The output quality is now limited by the quality of your specification and your review, which are the two skills that used to matter far less than the ability to perform the steps well. The same person does both jobs at different stages of the week, and the imbalance between the two modes is where the performance gap between teams will appear.

The interesting consequence is that the rituals of staff management reappear around software. Onboarding: your new agent needs a clear account of the context it is working in, the source systems it may touch, and the standard the output has to meet. Performance management: outputs need a review cadence, or they degrade quietly, the same way a hire with nobody checking drifts. Feedback: instructions need follow-ups, exactly the loop you use with a human, and a follow-up that names the gap rather than the tone. Any manager who has run a weekly review will recognize the pattern, because the old skill set of managing people transfers to machines better than the old skill set of operating tools ever did.

The change also re-prices the artifacts of your day. When software was a tool, the deliverable was the document, the script, the deck, and the file system was the honest record of what got done. When software is staff, the deliverables of the job are the brief, the constraints document, and the review note, because those are the instructions the staff run on. The artifacts that survive you are the ones that describe what was wanted. A week of delegated work leaves a trail of instructions rather than a trail of keystrokes, and the trail is what the next person, or the next audit, will read.

Which of these changes first? The review cadence. Before adding an agent to anything, write one line for how the output will be checked, and by whom, and put it on the same ticket as the task. Then write the brief, then hire. The version of this order that fails is the reverse: the agent arrives because it is easy to hire, and the review never exists because nothing ever gets checked, and month three discovers a confident, expensive mess that has been quietly accumulating. That is a staffing mistake, and it is now a software mistake too, which is the price difference you noticed.

At the Berlin keynote, Jensen Huang demonstrated the agent relationship with a robot duck. He spoke to it, and it lay down, rolled over, and took a nap, on command, in public, with no keyboard anywhere in the loop. The demo is small and the lesson is large: when the machine is your hired helper rather than your tool, the command layer is the product, and the natural command layer for a helper is speech. A duck does not have a settings panel, a keyboard, or a tutorial, and remarkably, neither does the next generation of your daily tools, which means the mechanism of control has moved into the one place it cannot be hidden from you.

Notice also how the duck demo handles imperfection. If the duck had not rolled over, the next act is not opening a settings screen; it is saying the command again, differently, more specifically. The iteration lives in language, not in configuration. That is the shape of the whole agent era: the fix for an unclear instruction is a clearer instruction, delivered directly into the conversation, and the conversation is the work. Interfaces that require a detour through menus and settings are interfaces that teach people to stop fixing their requests and start blaming the tool, which is the most expensive habit an agent team can develop.

Transfer the lesson to your own work. Your duck is the agent that summarizes the thread, drafts the brief, queries the data, or generates the first pass of the report. You say what you want, you watch it happen, you say it better. The loop feels casual, which is why people underestimate it: it collects no keystrokes and produces no log file that looks like work, and on a time sheet it looks like nothing happened. But the whole quality of the engagement lives in those exchanges, and the exchanges are where the difference between a good agent team and a bad one gets decided.

The voice-first nature also changes where the command originates. Commands no longer wait for you to be seated at the machine with hands ready; they leave while you are walking, thinking, or standing in the doorway of a meeting you just left, and a command captured at that moment is a command that still carries the thought. The interface that follows thought rather than waiting for hands is the interface that gets used. The duck was only a demo, but the direction it pointed is the interface of the new job description: spoken direction, fast iteration, and nothing between intent and command.

Take the description that governs your own role and rewrite it as if the computer were a member of your team. The what-you-will-do section stops listing tools and starts saying what you direct: what you specify, which outputs you review, at what cadence, against which criteria. The qualification line that used to say proficiency in an application now says something like a track record of clear specifications and a habit of checking outputs against stated criteria. Read your own rewritten description out loud once, and notice how much of the old one was about performing steps and how much of the new one is about deciding and checking.

The skills section grows by exactly one skill in the honest version: asking. Not the phrasing of it, but the discipline of stating outcome, constraints, and a definition of done before execution starts, and the willingness to re-ask when the first result reveals what you actually needed. That skill was always the one doing the real work inside a good typing job; the good coder was the one who knew what the code was for, and the good analyst was the one who knew which question the brief was hiding. The new description simply admits it, and naming it is the first step in being paid for it.

Then apply the same rewrite to the opportunities you would accept, and the ones you would decline look different. If a role is defined by the volume of output its holder produces, and output is now cheap, the role is already on the wrong side of the pricing, and no amount of tooling affinity will pull it back. If the role is defined by what decisions its holder makes and how clearly the holder directs, the role is on the right side. The rewrite is a filter as much as it is a document, and it is the filter you want to run every opportunity through.

The rewrite is also the practical artifact for the interview. Bring a brief instead of a portfolio of outputs: one page showing outcome, constraints, criteria, and the review note that followed, the artifacts a director actually produces. The brief demonstrates the skill the new economy actually buys, while a pile of documents demonstrates the skill it no longer needs. If that feels like a strange way to present yourself, the discomfort is the sign of the job description doing its job, because the interview has caught up with the shift a little faster than you had, and the brief is the way to meet it.

There is a gap between saying you want something and handing an agent a usable brief, and the gap is not about the quality of the ears. The speech stack the industry just shipped is impressive: the Riva speech library with NIM microservices gives you a fully offline voice pipeline on a single GPU, and Nemotron 3.5 Transcribe, open-sourced in late October, handles 40 languages, diarizes up to eight speakers, and ingests an hour of audio in a single pass, with the open Granary 2 dataset behind it. TechCrunch described the moment as voice AI in vogue, and the description is fair: the ears and the throat have been built.

But that stack produces transcripts, and a transcript is not a brief. The transcript preserves the ums, the restarts, the digression you corrected out loud and therefore never typed, and the half-sentence you meant to replace, because faithful transcription is the whole point of the model. NVIDIA built the ears and the throat, and the layer from hearing to understanding what you actually wanted to say is still empty, and it will stay empty until someone builds the part that asks what you meant. That layer is the one the agent needs, because an agent cannot reason around a mess it has faithfully recorded, and a verbatim brief is a mess with a timestamp on it.

Expression Intelligence is the name for that layer, and it is the part Voiskey builds: understand the real intent behind the utterance, strip the fillers and verbal missteps, and deliver text that is ready to send or ready to hand to an agent. The workflow is spelled out in its name: speak, polish, type, edit. It runs as a system-level voice input on Mac and Windows, produces output in 100+ languages, keeps audio local by default with zero server retention and SOC 2 Type II attestation, and for teams can sit entirely on your own GPU, the same offline pattern NVIDIA's NIM lineup supports. The stack hears; the layer understands; the brief arrives ready.

With the layer in place, the path from spoken command to agent-ready brief is short. You speak the outcome and the constraints while they are still in your head, the polish step removes the noise and keeps the intent, the type step drops the structured prompt where your agents expect it, and the edit step is where you keep the judgment that makes the engagement yours. Try it once on the task you were going to delegate next, and read the brief that comes out: it will be closer to what you wanted than the one you would have typed, because it left before the thought had time to go stale.