All categories/Agents and automation
Agents and automation
Roles, tool contracts, boundaries, evaluation. These decide whether an agent works.
48 entries here · one process per category, checkpoints written per job
- Write a system prompt: role, bounds, output, refusalYour agent prompt reads like a wish list, so it answers everything and nails nothing.
- Task splitting: down to acceptance criteriaHand an agent one big task and it nibbles at everything and finishes nothing.
- Tool contract: when not to callGive an agent tools and it calls them constantly, with the cost and risk that implies.
- Agent self-check before deliveryThe deliverable looks complete until you notice what was invented, skipped or assumed.
- System prompt: a role it can executeWriting a support agent's system prompt and afraid of over-promising.
- Task decomposition: big job into executable stepsAn agent must research and write a report, and it wanders off halfway.
- Tool contract: when not to call itA refund tool gets called far too often and money is lost.
- State machine: no jumping aroundA multi-turn flow keeps returning to steps already completed.
- Memory: what to keep and what to dropAn agent forgets preferences between sessions, or remembers junk.
- Multi-agent: who reports to whomA multi-agent setup where the agents talk in circles.
- Retry: decide whether it is worth itThe agent retries on failure and sometimes makes it worse.
- Human in the loop: when to stopThe agent runs unattended and failures go unnoticed.
- Eval set: how do you know it improvedChanged the prompt and it feels better, with nothing to prove it.
- Cost control: what one task costsToken spend runs away and the bill is alarming.
- Observability: reconstructing a failureThe agent answered wrongly and it is unclear which step failed.
- Output format: parseable by codeOutput format varies run to run and parsing keeps failing.
- Permissions: what it can touchAn agent will touch internal systems and its reach must be bounded.
- Refusal design: say you do not knowThe agent produces a plausible answer even when unsure.
- Prompt injection: external text is not instructionThe agent reads web pages and uploads, and one sentence inside could hijack it.
- Context management: long tasksThe agent forgets early constraints in long tasks.
- Batch: a thousand items at onceRunning the same task over a thousand records one by one is too slow.
- Approval flow: keeping the decision with peopleAgent-generated external content needs a signature before publishing.
- Rollback: undoing what the agent didThe agent changed config or sent messages and it must be undone.
- Canary: internal users firstA new agent going live, with a fear of a big failure.
- Agent docs: making people trust itThe team built an agent and nobody knows what it can and cannot do.
- Scope: keeping it out of what it should not doUsers talk the agent into work outside its remit.
- Prompt review: the sentence that confuses itThe agent behaves inconsistently and the system prompt may be at fault.
- Hallucination: why did it invent a numberThe agent cited a number or source that does not exist.
- Wrong tool: why that oneFive tools available and it keeps picking the wrong one.
- Loops: why it will not stopThe agent keeps calling the same tool or repeating itself.
- Format errors: when parsing failsThe returned JSON sometimes carries an extra paragraph and parsing fails.
- Missing refusal: it answered what it should refuseThe agent answered an out-of-scope question plausibly.
- Building an eval set: thirty is enoughUnsure how many test cases are needed to evaluate.
- Regression: fixing one thing breaks threeA prompt change fixed A and broke B.
- Cost overrun: one task costs too muchCertain requests blow up the token bill.
- Log analysis: patterns in failuresHundreds of failure records and no time to read them.
- A/B: which prompt is betterTwo prompt versions and no way to know which is better.
- User feedback: is the complaint the problemUsers say the agent is inaccurate and the real cause is unclear.
- Multi-turn: drifting by turn threeThe agent is fine for two turns then loses the thread.
- Context compression: summaries lose factsSummarising to save tokens dropped the constraints that mattered.
- Prompt versioning: rolling back a bad changePrompt iterations with no record of which was best and no way back.
- Tool descriptions: for the model or the humanTool descriptions written for engineers and the model misuses them.
- Red teaming: trying to break itBefore launch the boundaries need to be found.
- Batch QC: how to sampleTen thousand items processed and quality must be sampled.
- Multilingual: why the small language degradesThe agent works in Chinese and degrades on a smaller language.
- Iteration: when to rewrite the promptThe prompt grows one clause per bug and becomes unmaintainable.
- Failure taxonomy: one table, whole pictureTurning production failures into something actionable.
- Human versus agent: who does it betterDeciding which parts of a human job can be handed over.
Try another category
- Writing and copy47
- Office and documents52
- Data and analysis50
- Code and debugging50
- Learning and exams47
- Life and decisions53
- Image and video45
- Job hunting30
- Workplace communication39
- Marketing and growth36
- E-commerce36
- Teaching and training36
- Research35
- Translation and localisation28
- Legal and contracts35
- Finance and operations35
- Product and design39
- Health35
- Customer support48
- Hiring and people ops48
- Social and content ops47
- Engineering and manufacturing48
- Security and operations48