Autonomous Agents, Tool-Calling Definitions & Workflow Chains

Generate the opening identity/environment block of an agent prompt so the model knows who it is, where it runs and what it may assume.

Rewrite a failing tool interface so mistakes become structurally hard to make, using format choices that suit how models write.

Choose between calling specialists as tools and handing the conversation to them, per interaction, with a documented rationale.

Design a multi-branch pipeline where a decision component routes inputs to type-specific processing paths that later rejoin.

Generate a structured capability manifest that tells a general-purpose agent what it can do and where its boundaries sit.

Choose between fixed, semantic and model-based chunking for a corpus and pair it with an overfetch-and-rerank retrieval plan.

Build a routing step that classifies an incoming request and dispatches it to a specialised downstream prompt, tool set and model tier.

Move flow control out of the model: chain agents in application code using structured outputs, parallel execution and an evaluator loop.

Design a retrieval tool that writes passages to a filesystem and returns paths, plus an analyst subagent prompt that reads one passage at a time.

Build a coordinator that delegates by transferring control to specialist sub-agents chosen from their descriptions.

Write a reviewer agent's system message that emits a machine-detectable approval token when its feedback is satisfied.

Set up a generate-evaluate-revise loop with explicit criteria, feedback format and stopping conditions.

Express a multi-step workflow as typed events between steps, with branching, loops, shared state and a validated event graph.

Author a small set of function declarations with strongly typed parameters and select the correct calling mode for the use case.

Define handoff tools that transfer control between agents while carrying an explicit payload and remaining valid in the message history.

Specify the offline indexing half of a RAG system with concrete loader, splitter, embedding and vector-store choices plus refresh policy.

Write a client-side tool definition where the description states the capability and every property description carries its expected input format.

Specify an agent turn format that interleaves an explicit reasoning trace with tool actions and observations, so plans can be tracked and repaired.

Author server-exposed tool definitions for a protocol tool listing, with namespaced names, display titles and validating input schemas.

Design ingestion-time metadata labelling and query-time filters that narrow the search space before semantic matching.

Specify the smallest viable agent harness: model, tool list, system prompt and the middleware layers added on top.

Produce a sectioned, modular system prompt for an autonomous agent so identity, tooling, planning and safety rules stay separable and auditable.

Design a central orchestrator that decomposes an unpredictable task at runtime, dispatches worker prompts and synthesises their returns.

Design declarations that make independent actions callable in parallel and dependent actions chainable, then validate the resulting call plan.

Run independent agents concurrently into distinct state keys, then gather them in a following synthesis step without race conditions.

Split a task into independent sections evaluated concurrently, then aggregate results in code rather than in a model call.

Define how retrieved nodes are filtered and reordered before synthesis, and constrain the synthesiser to the surviving evidence.

Decompose a task into a fixed sequence of model calls where each step consumes the previous output and a code gate blocks bad handoffs.

Insert a rewriting step that converts conversational user questions into retrieval-optimised query forms without losing constraints.

Lay out all five RAG stages with the concrete component choices and success measure for each.

Define refusal categories, exact refusal wording and approval tiers for an autonomous agent.

Write the system instructions for a retrieval agent that plans queries, searches, analyses evidence, synthesises with citations and refuses to answer from memory.

Specify a router that selects one or more candidate retrievers per query based on retriever metadata and query shape.

Turn a job description into a framework-ready agent definition with role, goal, backstory and behaviour settings.

Configure a shared-context turn-taking team whose stop conditions combine a keyword signal, an external stop and a hard cap.

Wire a bounded generator-validator loop inside a pipeline so malformed output is fed back for correction before continuing downstream.

Chain agents in a fixed order where each writes its result to a named state key that the next step reads, with validation gating.

Decide what each agent shares on the common channel and how messages are attributed so long histories stay legible and bounded.

Write the operating guidelines for a coding agent covering communication triggers, root-cause discipline, convention matching and check-running.

Produce a strict-mode-compliant function definition whose JSON Schema forbids extra properties and marks every field required.

Design a supervisor that routes work to specialist agents using structured next-agent decisions and receives control back after each turn.

Audit an existing tool set and redesign it so invalid states are unrepresentable and the model is not asked for arguments the app already knows.

Tune how eagerly a model reaches for tools by writing graded system-prompt instructions and choosing when to force a call instead.

Write the behavioural rules that govern how an agent narrates, sequences and verifies tool calls.

Turn plain Python functions into agent-ready tools by supplying type hints, return types and docstrings that carry the whole contract.