Task Framing

Task framing is the first and most critical pattern in any agent UI. It is the structured surface that converts a users high level goal into a complete specification the agent can trust. Instead of tossing a vague sentence into a chat box the user fills or confirms a set of fields tailored to the task type. For a coding agent those fields include target files, acceptance criteria, test cases, and performance targets. For a design generation agent the fields cover brand guidelines, example assets, output resolution, and usage context. The AI parses the initial description and proposes values for each field. The user edits what looks wrong. Only after the frame is locked does the agent generate its plan. This pattern sets the contract. It removes ambiguity that would otherwise plague every later stage from autonomy settings to error recovery. Without solid task framing the entire agent experience collapses into a guessing game dressed up as intelligence. Good framing surfaces turn supervisors into confident directors instead of anxious babysitters.

Task framing is not a free form text area that invites the user to type whatever comes to mind. It is not the chat first pattern that dominated early agent releases in 2023 and 2024 where the agent spent half its cycle asking what the user really wanted. That approach fails because language is lossy and agents make terrible assumptions when left to their own devices. Task framing is also not a static form with fifty mandatory fields that slows the user to a crawl. The best versions feel like a conversation that quickly hardens into structure. They use smart defaults, natural language parsing, and inline suggestions to keep momentum while still capturing precision. Products that get this wrong train their users to add paragraphs of instructions that the agent then ignores or misinterprets. The result is frustration on both sides and a product that demos better than it ships.

Concrete examples prove how powerful tight framing can be. Linear AI shipped the clearest version in 2024. Their interface takes a short brief like redesign the settings page for better mobile usability and instantly populates an issue with title, description, labels, priority, and a list of acceptance criteria the AI inferred from similar past tasks. The designer clicks into any field to refine. They add a note about dark mode compatibility. They adjust the priority from medium to high. The structured output then feeds the agent a clean machine readable brief instead of a wall of text. This leads to plans that match intent and progress streams that stay relevant. Cursor follows a parallel pattern for its composer agent. Users select files first then describe changes but the framing step requires them to classify the task as bug fix, feature, or refactor and to attach relevant tests or screenshots. Devin expanded the concept to its full workspace by letting users frame tasks with references to open browser tabs, specific code sections, and even natural language success descriptions that the agent turns into executable checklists. On the design side tools like v0 and Lovable force users to define the component library, styling system, and interactivity level before generation begins. Bolt improves on this by offering preset frames for common products like landing pages or dashboards that prefill many fields. These are not theoretical. They are shipping products that demonstrate why task framing is the foundation. Each one converts fuzzy intent into discrete editable pieces. Each one reduces the number of times the user must interrupt the agent mid run. The difference in trust is immediate.

Designing the framing surface requires thought. Place the natural language box at the top. Show the parsed structure below it in real time as the user types. Use chips for labels, dropdowns for categories, and text areas for descriptions. Add a completeness meter that turns green only when every required field has content. Let the user save common frames as templates for repeated task types. This turns framing from a chore into a power tool. The best surfaces feel like they read your mind while still giving you final say. That balance is what separates toy agents from production ones. Connect the framing layer directly to the plan surface so edits in one instantly update the other. Tie it to autonomy controls so a tightly framed task can safely run with higher leash settings.

Use task framing for any agent that performs real work with real consequences. Deploy it in internal tools that touch customer data, in coding agents that push to GitHub, and in creative tools that output final assets for production. Use it when you want to minimize the need for constant oversight or when autonomy levels are set high. The clearer the frame the safer the autonomy. Apply the pattern when building handoff artifacts because a well framed task becomes the perfect starting point for the next teammate or agent. Avoid full structured framing for open ended research tasks or casual exploration where the goal is discovery rather than execution. Do not force it on simple queries that a basic LLM call can resolve in one shot. Skip heavy framing in prototype agents running in sandboxes where nothing permanent can break. But the moment the agent leaves the sandbox and starts touching the real world bring the full framing surface online. Teams that follow this rule ship agents users actually trust. Teams that ignore it build elaborate error recovery and confirmation gates to compensate for problems that started with bad inputs. The pattern pays dividends immediately. One well designed framing surface prevents dozens of downstream failures.

Task framing turns ambiguous requests into precise contracts that make agents reliable instead of merely impressive.