What I can build with AI agents

An AI agent is software that perceives, decides and acts toward a goal - not a chatbot that waits for the next message. Once you see that loop, every agent product reads the same way.

Builders think in loops and constraints: what the agent senses, what it may do, and when it must stop and ask. A clear boundary beats a clever prompt every time.

Every agent starts as a one-page blueprint: the job, the inputs, the tools, the limits. Writing it first saves weeks of rebuilding later.

A prompt becomes an agent when it assigns a role, states the job, and sets the rules for edge cases. Vague prompts produce vague agents.

Shipping means the agent lives somewhere real people can reach it, not in a demo chat. Foundations are the unglamorous parts: inputs, outputs, and what happens on failure.

A tour of what production agents look like from the inside before building each part. Knowing the whole machine first makes every later lesson land somewhere.

Good prompts are specifications: role, context, format, examples, and what to do when unsure. The example outputs carry more weight than the instructions around them.

Tools turn talk into action: the model decides what to call, your code does the thing. Each tool needs a name, a schema and an honest description of when to use it.

MCP is a standard plug for tools: one protocol connects the agent to files, apps and APIs. Learn the plug once, reuse it everywhere instead of custom wiring per app.

Skills package know-how the model lacks: procedures, checklists, domain rules. A skill is cheaper than fine-tuning and editable by a human in minutes.

Memory lets the agent pick up where it left off: preferences, history, ongoing tasks. Store facts with owners and timestamps, or memory becomes confident misinformation.

Reliable agents check their own work and retry with a limit: verify, fix, try again, then hand to a human. An unbounded retry loop is an infinite bill.

RAG grounds answers in your documents: retrieve the relevant passages, then answer from them. The retrieval quality decides everything; the model just writes up what it was given.

Evals and traces make agent behavior visible: score real runs, replay failures step by step. What gets measured gets fixed; everything else is vibes.

Subagents split hard jobs: a coordinator plans, specialists execute, someone verifies. Small focused agents beat one giant agent that does everything badly.

A support persona is a role plus a voice: who it serves, how it sounds, what it never does. Customers trust an agent that feels like the same teammate every message.

Grounding ties answers to your documents so the agent quotes your policy instead of the internet's average. No grounding means confident fiction with your logo on it.

Hardening is knowing when to say no: refuse what is outside the docs, escalate anger and big money to humans. A handoff done well is a feature, not a failure.

Prove it with hard test cases before shipping: tricky questions, out-of-scope traps, angry customers. The trace shows what happened; fix the prompt, not the demo.

Vibe coding works when you describe the outcome precisely and run what comes back. The builder's job shifts from typing code to judging it.

Directing AI is a skill: break the build into steps, state constraints up front, review each part before moving on. Vague direction produces vague software.

Doing it properly means verifying: run it, click through it, check edge cases. Untested AI code is a demo; tested AI code is a product.

A real build end to end: plan, generate, verify, fix, ship. The loop matters more than the tool; tools change monthly, the loop does not.

Graduation standard: specify precisely, verify ruthlessly, ship something strangers can use. That bar is what separates builders from prompters.

Most business WhatsApps drown in the same five questions: price, stock, hours, delivery, location. An assistant that handles the repeats gives humans back their day.

Your shop's voice in text form: short, warm, rojak where natural, never corporate. Customers can smell a generic bot in one message.

The assistant reads from your real price list and FAQ, so prices and policies are always current. Update the document once and every answer updates with it.

Shipping means a shareable link real customers can open today; the real WhatsApp API connection comes later through official providers. Demo first, plumbing second.

A web page is a text file with labels: headings, paragraphs, links. The browser does the drawing; you describe the structure.

Right tags for the right meaning: headings for sections, lists for lists, links for actions. Screen readers and Google both read structure, not looks.

Tailwind styles with short class names right in the markup: size, color, spacing. No separate stylesheet to lose track of.

Every element is a box: padding inside, margin outside, rounded corners, shadows. Spacing is what makes a page feel designed rather than dumped.

Flexbox lines things up in a row with proper spacing: navbars, button groups, toolbars. One class row, no float hacks from 2009.

Grid arranges even columns: card grids, galleries, feature sections. Three equal cards is one line, and it stays equal everywhere.

Small reusable pieces users click: buttons, badges, call-to-action blocks. Build once, stamp everywhere, stay consistent.

One page, every screen: breakpoint prefixes reflow columns for phones. More than half your visitors are on mobile; design there first.

Hover states and transitions make pages feel alive: buttons respond, cards lift, changes ease in. Polish is feedback that the page heard you.

Everything assembled: navbar, hero, grid, call to action, footer, responsive, polished. A real landing page from zero, shippable to a friend.

A copywriter agent turns product facts into a Shopee title, a description and captions. Same facts in, selling words out, every single time.

Brand voice is taught with examples, not adjectives: show the model listings that sound like you. Three good examples beat three paragraphs of description.

Seasonal angles reuse the same engine: Raya, 11.11, back-to-school are just new hooks on proven facts. Plan campaigns as inputs, not rewrites.

The SDK gives you agents as code: define, run, inspect. No drag boxes, no hidden state - everything you built is readable Python.

Function tools let the model act: clear names, type hints, one-line docstrings become the schema the model sees. Bad descriptions produce bad tool calls.

Two tools force a real decision: the agent must choose which tool fits. Watching it choose correctly is the moment tools click as a concept.

Typed answers via pydantic: the model returns data your code can trust, not prose you must parse. Two fields minimum keeps it honest.

Triage plus specialists: one router sends each request to the right expert. Small focused agents beat one giant agent at everything.

Input guardrails check messages before the agent acts: blocklist topics, detect injections, enforce policy. Safety at the boundary, not as an afterthought.

A complete multi-tool agent designed end to end: role, tools, and the judgment to use them. The whole SDK in one working build.

LangGraph models an agent as a graph: shared state flows through nodes along edges. You build it, compile it, invoke it - the whole mental model in one idea.

The ReAct loop by hand: model node, tool node, conditional edge looping until done. Building it manually teaches what every framework hides.

Conditional edges branch on decisions: classify first, then send each case down its path. Routing is how one graph serves many intents.

create_agent compresses the whole loop into one line once you understand it. Shortcuts are safe only after you have built the thing manually.

A supervisor routes work to specialist workers and decides when the job is done. Real orchestration: plan, delegate, synthesize.

Direct handoffs skip the supervisor: agents pass work to each other with Command. Decentralized teams for jobs where everyone knows the next step.

Checkpointers give graphs memory across turns: same thread id, full context. Conversations finally continue instead of restarting.

A designed multi-step workflow with routing or tool loops, built from scratch. The whole graph engine in one running build.

AI forgets everything between chats by default. Memory is a separate system that stores facts with owners and timestamps - it is not RAG and not hopes.

A memory server runs locally: one binary, your data stays yours. Storing the first memory proves the loop works before anything fancy.

Container tags keep memories apart: one server, many users, zero leakage between them. Scoping is the difference between personalization and a privacy incident.

Plain-language search over memory with hybrid retrieval: keywords plus meaning. Ask like a human, get the facts that matter.

One call builds a user profile: stable facts plus what they are doing now. No manual feature engineering, the engine assembles it.

Documents and memories answer together: shared knowledge plus personal context in one query. The doc says the policy; memory says your situation.

Facts change: good memory tracks when something became true and resolves contradictions. Stale facts get replaced, not piled up.

The recall-answer-remember loop: pull context before the model, store what was learned after. Every turn makes the next turn smarter.

Metadata tags plus filtered search narrow retrieval to exactly what counts. Tags are the scalpel where container tags are the cleaver.

A personal assistant that recalls, answers and remembers per user. Memory plus agent in one running build.

Pi gives you the loop, state, tools and events as primitives - the product around them stays yours. Own the harness instead of renting opinions.

Streaming event bridges push text deltas to the browser live over SSE. Users watch answers form instead of staring at spinners.

Typed tools with TypeBox schemas turn chat into software that acts. Strict schemas plus thrown errors keep the model honest.

One session map per browser ID: every visitor gets an isolated reusable agent. No leakage, no shared state, no cross-talk.

Stop and steer controls act on live runs: abort the right session, inject follow-ups mid-stream. Users stay in charge of running agents.

Server-side tool policies gate destructive calls before execution: allowlists, approvals, termination. No fake sandbox popups - real boundaries.

The full web agent: streaming, tools, sessions, controls and policy in one TypeScript build. Yours all the way down.

Gemini agents that actually call tools: register the function, instruct the model to use it, verify the call happened. A tool never called is decoration.

Pipelines where each step feeds the next through shared state: draft then polish, research then write. Order guaranteed by edges, not hopes.

Fan-out with JoinNode runs branches together then merges; routed edges send each case to its specialist. Parallel where possible, precise where it matters.

Coordinators with sub-agents: the boss routes, specialists execute, delegation is verified by who actually answered. Teams, not monoliths.

A designed multi-step Gemini workflow with tools, run cleanly end to end. The whole ADK toolkit in one build.

The calling loop written by hand: append the assistant message, keep the tool_call_id, handle every parallel call, always terminate. Fifteen lines that explain every framework.

The schema is the contract: enums, required lists, no extra properties. Anything left open becomes a mistake the model will eventually make.

Descriptions route the model where schemas cannot: identical tools with identical blurbs are a coin flip. The description is a routing decision, not documentation.

Return values are billed every turn: drop the plumbing, cap the rows, announce truncation. A thin return makes the model write paragraphs; a finished sentence gets relayed.

Errors are results: name the field, state the valid values, never a traceback. A good error gets a correct retry on the first attempt.

One tool doing the join beats five thin wrappers: fewer calls, fewer tokens, better answers. Do the join in your code, not in the model's context.

Destructive calls need idempotency keys and approval gates: same key twice moves money once, big amounts wait for a human. Retries must be safe by design.

Fetched content is attacker input: cut one leg of the exfiltration trifecta and the path closes. The property to prove is the closed loop, not the technique.

Build the eval before tuning: a harness that can fail, fixtures with good and bad tools, metrics that match exactly. Unevaluated tuning is taste, not engineering.

Shipping every tool on every call has a ceiling: schemas are re-sent per turn, so tool count is itself a budget. That pressure motivates search and MCP.

Porting keeps what decorators cannot invent: constrained enums, worked examples, real attachment to the agent. The schema the decorator generates still needs your intent.

A shipped suite inside a token budget: trimmed schemas plus behavior facts in descriptions. Two sentences of boundary-setting beat a thousand characters of schema.

RAG from the outside first: watch a question get answered from documents before learning the machinery. The demo sets the target everything else builds toward.

Documents split into retrievable chunks: size and overlap decide what can ever be found. Bad chunks guarantee bad answers regardless of model.

Embeddings turn text into searchable vectors: meaning becomes distance. The model choice here sets cost and quality for everything downstream.

Vector storage with metadata and namespaces: scale, filtering and tenancy live here. A database decision, not just a folder of vectors.

Retrieval by meaning instead of keywords: top-k, thresholds and query rewriting. This is where users feel quality differences.

Reranking re-orders candidates with a stronger model: cheap retrieval first, expensive judgment on the finalists. Precision where it counts, economy everywhere else.

Answers with citations plus honest refusal: quote sources, decline when absent. A cited answer can be checked; a refusal beats a fabrication.

Retrieval evals measure what matters: hit rate, faithfulness, refusal quality. Numbers replace arguments about whether the search is good.