What Are Agentic Workflows? A Complete Guide for Developers
Key Takeaways
- An agentic workflow is a goal-driven process where an AI agent plans, retrieves the information it needs, acts, and self-corrects, deciding its next step at run time.
- Agentic workflows work differently from traditional automation, which follows predefined code paths. The agent decides what action to take next based on what it perceives and reasons.
- The core components of an agentic workflow are a foundation model that handles reasoning, planning, and orchestration, plus memory, tool use, and monitoring.
- An agentic workflow can reach sites that have no API. TinyFish customer, Google Hotels, uses one to check availability across 40,000+ Japanese hotel sites.
Gartner predicts that by 2029, agentic AI will be the new normal for enterprise applications. But leaving it at that would be sharing a photo from a narrow lens. The bigger picture is, in the near future, human and AI collaboration is expected to evolve.
In this developer guide, we loop you into what agentic workflows are (pun intended!) and how they work to solve complex and simple problems alike.
You’ll learn the components you need to build one yourself plus practical use cases you can try today with TinyFish, a browser agent supporting web-based agentic workflows. By the end, you’ll be able to solve a pressing problem agentically.
What Are Agentic Workflows?
An agentic workflow is a goal-driven process in which one or more AI agents decide and take the steps needed to reach a goal, adapting as conditions change, rather than executing a predetermined sequence.
According to Anthropic, workflows are “systems where LLMs and tools are orchestrated through predefined code paths," while agents "dynamically direct their own processes and tool usage."
Simple visual from Anthropic showing how an agentic loop works.
As a working example, let’s do some dogfooding by agentically extracting information from TinyFish’s Trust Center, using TinyFish Web Agent. We're using an agent instead of a simple Fetch call because this task has to interact with the page, working through several steps rather than reading a single URL. Fetch already handles JavaScript-heavy pages, so what calls for the agent here is the interaction, not the rendering.
Step 1: We’ll start by defining the GOAL. Here, we explain in Natural Language, or plain words, what we want the agent to achieve in this run.
Step 2: The AGENT RUN itself. As you’ll see from the screenshot below, TinyFish’s Web Agent lists out all the steps it takes to achieve the goal we outlined earlier. It takes screenshots of the page and via a multi modal LLM reviews the image pixels like a human would.
Step 3: RESULTS. When the agentic workflow ends and the goal is complete, the resulting information is presented as structured data such as JSON or CSV formats. In this specific example, the data was presented as a rendered markdown file.
The word "agentic" points to the model’s capacity to act and choose. TinyFish’s Web Agent is able to strategize and make decisions in seconds to ensure that the goal is completed.
Take a closer look at some of the on-the-fly run time decisions for our example workflow:
Agentic workflows on live websites are run by web agents. To understand web agents in depth, read our guide on what a web agent is.
Agentic Workflows vs Traditional Workflow Automation
Traditional automation follows rules written in coded scripts in advance. An agentic workflow decides the next step at run time, based on what it perceives through screenshots, DOM parsing, and accessibility tree analysis.
View agentic workflows vs traditional workflow automation side-by-side:
| Dimension | Traditional automation | Agentic workflow |
|---|---|---|
| Decision logic | Fixed rules written in advance | Decided at run time from observations |
| Handling the unexpected | Breaks or stops | Re-plans and adapts |
| Inputs | Predefined fields and triggers | Open-ended goals in natural language |
| Data freshness | Whatever the integration was wired to | Whatever the agent can retrieve as it runs |
| Maintenance | Update the script when the site or rule changes | Agent adjusts to many changes on its own |
In summary, while traditional automation scales for repetition, agentic workflows scale for judgment.
Think: "do exactly this no matter what" vs "achieve this goal no matter what."
How Agentic Workflows Work
Every agentic workflow runs the same loop. Goal, plan, retrieve, reason, act, reflect. Then around again if the result isn't there yet.
These are the general steps a typical agentic workflow entails:
Goal Setting
You give the agent an outcome in plain language, like "find local suppliers for this part." No script, no selectors, just the result you want.
Gia-Thi Nguyen, a digital transformation leader who's held CIO and CFO roles, did exactly that, and his agent surfaced local suppliers he'd have missed. The clearer the goal, the less the agent has to guess.
Here's the log from that run, every query it ran and every source it checked:
Planning
The agent breaks the goal into an ordered set of steps and picks a tool for each one. Search here, read a page there, compare after that.
Maleeha Imran's BookDeal shows the shape: one command becomes a plan that checks live book listings across trusted retailers and ranks them, going from twelve tabs to one command.
If the plan turns out wrong or breaks mid-run, the agent can revise it instead of pushing a broken sequence to the end. You can watch that plan execute, searching each retailer, fetching the listings, then ranking them into one table:
Information retrieval
The agent gathers what it needs, usually from the live web. This is where data freshness enters, and where clean input matters.
Vibe-coding his portfolio, Anant Goyal found Claude's built-in fetch returned noise while TinyFish Fetch returned usable context.
Retrieval on the real page keeps the rest of the loop grounded in what's true now. The payoff is in the output, clean JSON and markdown from the page instead of raw HTML. See below:
Reasoning
With that context in hand, the agent weighs the options and decides what to do next. The win is picking the context that matters and dropping the rest.
Mohammad Varmazyar's open-source web-research tool cut one benchmark from 23,851 estimated tokens to a focused set, so the model reasons over signal and not wasted junk tokens.
This is the judgment step a fixed script can't do. The pipeline that gets there is short: query, search, fetch, clean, then focused JSON to the model:
Execution
The agent acts. On a website that means navigating, filling forms, working through pagination, signing in, and pulling out the data.
CanyonRift, built by Yash Negi and Andres Romero, runs this against payer portals, using TinyFish as a browser-intelligence layer to return reviewer-usable medical-policy findings. Execution is also where things break in the wild, so it's the step worth watching most closely.
Here, TinyFish is the research instrument inside a five-step workflow that runs before results reach a human reviewer:
Reflection
The agent checks the result against the goal, and loops back if it's off. Some builders make that checking the point.
LaSalle Browne's Coherence Intelligence Terminal coordinates several agents across government databases and public records, then surfaces the contradictions between sources instead of collapsing them into one confident answer.
Reflection is what turns a one-shot attempt into a workflow that can recover. Its mission-control view makes that checking visible: a live feed, an entity graph, and the status of each investigating agent:
Bonus: Orchestration
Orchestration is the layer that drives the agentic loop, deciding after each action whether to keep going, re-plan, or stop, and carrying what the agent has learned into the next step so nothing gets dropped.
Some workflows plan once and execute straight through. Others run a tighter loop, acting, reading the result, and adjusting before the next move, which is how the agent recovers from a wrong turn instead of failing on it.
The loop only holds together when the hand-offs are clean. Give each step a consistent, machine-readable result to pass along, and the next step reads it without guessing, so a long workflow stays reliable at scale instead of drifting.
Bigger jobs split the work across several agents. A planner hands pieces to task-specific sub-agents, each owning its part, and for anything that runs on a live website the specialist is a web agent. It navigates, signs in, and extracts while the model does the reasoning. Hand software that much autonomy and a fair question follows: who's accountable when nobody decided?
The Core Components of an Agentic Workflow
Six parts make up a working agent. They don't overlap, and together they cover the whole job.
| Component | What it does |
|---|---|
| Foundation model | The reasoning engine. It interprets the goal and decides the actions. |
| Memory | Short-term context for the task, plus longer-term recall across steps or runs, so the agent doesn't repeat work or lose the thread. |
| Planning | Turns a goal into an ordered set of steps, and re-plans when a step fails. |
| Orchestration | Runs the loop: routes each step to the right tool, passes state between steps, and decides when to loop, re-plan, or stop. |
| Tool use | Calls functions and APIs to act beyond text, like web search, code execution, content retrieval, and browser control. Web access is the core of it. |
| Monitoring | Logging, tracing, and evaluation, so a team can see what the agent did and catch failures. In production, that means run-level artifacts you can inspect after the fact. |
Take web access. A language model works from a fixed training snapshot, and a retrieval layer only reads what it has already gathered and can’t fetch live data.
Getting current data from real pages, especially pages behind navigation, forms, or a login, takes a web agent that operates the page, which a bare model or a retrieval layer can't do.
As Google's Agents whitepaper explains, "Generative AI models can be trained to use tools to access real-time information." The web agent operates the tools that navigate and execute on the web.
Examples of Agentic Workflows
The following are examples of agentic workflows based on the most common use cases we’ve seen.
Competitive Price Monitoring
The agent searches for a product across retailers, reads each listing, and returns a structured price table on a schedule.
Motorbike rental shops in Vietnam don't list prices on any aggregator. Vietnam Bike Scout fires a browser agent at five or six shops per city at once, reads each bike's daily and monthly price, converts VND to USD, and streams a sorted table back in 15 to 30 seconds.
Live research
The agent gathers current sources on a topic, reads them cleanly, and pulls the findings into a briefing with citations.
TinySkills takes a topic, runs one search per source type across docs, GitHub, Stack Overflow, and blogs, fetches the pages as clean markdown, and synthesizes them into a single guide with its sources.
Input:
Output:
Record enrichment from the live web
The agent updates a list of companies by reading their own pages and sources behind a login, reaching data a private-data provider can't, rather than curating from one.
Competitor Analysis takes a list of competitors, finds each one's pricing page, and runs agents in parallel to extract structured pricing into every record, reaching pages a private-data provider can't.
Discover more examples of agentic workflows in the TinyFish CookBook.
Benefits of Agentic Workflows
Agentic workflows save time by automating complex tasks that once needed human help. Because these systems can handle many tasks at once, your team can get more done without the usual manual copy-pasting. This lets your team stop doing repetitive busywork and focus on big-picture projects.
These systems are also more reliable than older automation methods because they look at live data instead of following strict, rigid rules. If a website changes or something unexpected happens, the agent adapts and keeps working. Plus, built-in monitoring means the system learns from its mistakes, turning your automation into a tool that gets better over time.
Challenges of Agentic Workflows
Agentic workflows are powerful, but they aren't magic. They’re complex systems with distinct failure modes. Understanding these hurdles is essential for moving the agents from prototype to reliable production.
| Challenge | Description |
|---|---|
| Hallucinations | Models can assert wrong facts. Live retrieval and validation layers reduce these errors, but they do not completely remove the risk. |
| Tool reliability | Every tool the workflow calls represents another potential point of failure. Builders must directly validate the content itself, as runs can finish successfully but return blocked pages. |
| Security | Agents act with real credentials. Access must be strictly scoped per run rather than per project to minimize the total blast radius. |
| Observability | Requires comprehensive logs and run-level artifacts like screenshots and HTML snapshots to diagnose failures. |
| Latency | Individual execution steps and external tool calls add substantial wall-clock time to the execution loop. |
| Cost | Multi-step autonomous runs continuously consume tokens and compute resources, compounding at enterprise volume. |
| Governance | Requires explicit ownership regarding operational and legal liability when software acts independently. |
Pro Tip: Never take a "completed" status at face value. A run can finish and still return an empty response, blocked or captcha page. Validate the content, not just the status.
Best Practices for Building Agentic Workflows
Follow these best practices to ensure the agentic workflows are built for production-grade stability and reliability.
- Set a clear, specific goal. Clearly defining the intended outcome ensures the AI stays on track and minimizes unnecessary execution loops. Also, the more explicit your goal is, the less tokens the agent has to use.
- Give the agent reliable tools. A clean retrieval and action layer beats a brittle stack of scripts. High-performing workflows rely on robust APIs and browser-intelligence layers rather than easily broken custom scraping scripts.
- Feed it current, high-quality data. Stale or noisy inputs cap the output. Utilizing real-time web retrieval grounded in live site content keeps the reasoning process accurate and factual.
- Monitor outputs. Log runs and validate results before anything downstream trusts them. Comprehensive logging, tracing, and run-level artifacts are critical to catching failure modes like hidden CAPTCHAs or blocked pages.
- Scope credentials and permissions to the task. Give the agent only what the job needs. Limiting system access strictly on a per-run basis reduces overall vulnerability.
- Keep a human in the loop where the stakes are high. Put an approval gate on anything you can't undo. Human review acts as a vital safety barrier for critical decisions that involve legal or operational liability.
Pro Tip: Scope credentials per run, not per project. The narrower the access, the smaller the blast radius when something goes wrong.
How TinyFish Powers Agentic Workflows
TinyFish gives a team one platform to search, read, browse, and operate the web, instead of gluing separate vendors together in stitched web stacks that fail in production.
Agentic work runs on the Web Agent. It takes a goal and completes the steps on the page, while Search and Fetch feed it and Browser gives it a session to run in. Here's what each surface does.
- Web Agent. The operator, and the surface that completes a task. Give it a goal and a URL, and it navigates live sites, fills forms, works through filters and pagination, authenticates, and returns results. Runs are metered.
- Search. Agent-optimized web search: fast, structured for AI consumption, returning live results an agent can act on directly. Free on every plan, and it works on its own or as the input layer before a Fetch or Web Agent call.
- Fetch. Clean content extraction from any URL. It renders dynamic, JavaScript-heavy pages and returns markdown, JSON, or HTML that's LLM-ready by default, up to 10 URLs per request, and it doesn't use credits. It strips the navigation, scripts, and cookie banners first, so the model reads the content and skips the junk. (Read: Why raw fetches return junk.)
- Browser. A managed, stealth cloud session your own Playwright or CDP script can drive. It's the infrastructure those actions run on. Automating the page itself is the Web Agent's job.
The reasoning in TinyFish Web Agent comes from TinyFish’s own model called Mako. But, TinyFish can also be used with models like Claude and ChatGPT as the web operating layer they call.
Which one do you reach for?
| Reach for | When |
|---|---|
| Search | You don't know the URL |
| Fetch | You know the URL |
| Web Agent | The task needs multiple steps on the page |
| Browser | You want to drive the session yourself |
Google Hotels runs this in production. Japan has more than 40,000 small hotels and guesthouses whose sites don't fit standard booking integrations. TinyFish agents navigate each booking flow, check availability, extract pricing, and feed structured results into Google Hotel Search, reaching that long tail and lifting search visibility 20 to 30%. In the words of a Google Hotels product lead, TinyFish "gave us the ability to reach supply we couldn't access any other way."
Every run leaves a trail, too. With capture config, TinyFish records step-level screenshots and full-page HTML snapshots, you can list and search past runs, and webhooks fire when a run completes, fails, or is cancelled. That gives a production workflow an audit trail to inspect after the fact.
Point an agent at your real target site, describe the goal in plain language, and get structured results in minutes. Start building on TinyFish with 500 free steps, no credit card.
CRM Data Enrichment Use Cases
Some of the data you need to keep a record current isn't for sale. It lives on the open web, spread across company pages and sources behind a login, and it changes over time. A web agent reaches that data by reading the live pages, including ones a private-data provider can't get to. This is deep enrichment: the agent goes to the source, instead of pulling from a dataset someone else packaged.
Four common use cases:
- Reaching sources behind a login: on accounts you're authorized to use, a web agent operates inside an authorized session to reach account state a read-only scraper never can.
- Keeping public pricing and plan data current: scheduled runs re-check public pricing pages and update the record.
- Verifying records against the live source: the agent confirms a company still exists at its stated details by reading its own site, and flags conflicts.
- Pulling from dynamic, protected pages: JavaScript-heavy pages that read-only scrapers miss, extracted through the web agent.
For authenticated work, TinyFish holds an ISO 27001:2022 certification, and its credential handling keeps the model from ever seeing raw credential values. They resolve at the browser layer and get discarded after use. Vault and Profiles handle the credentials and identity, so an agent can sign in without touching passwords.
The Future of Agentic Workflows
Agentic workflows are moving from demos into production, and the money is following. Grand View Research values the AI agents market at roughly $10.9 billion in 2026, on the way to $182.9 billion by 2033.
A few shifts are driving that. Multi-agent workflows split a job across specialized sub-agents that hand work to each other. The Model Context Protocol (MCP) lets those agents reach tools through one interface, and TinyFish Search and Fetch already work over MCP, so Claude Code or Cursor can call them without custom code. Long-running agents watch pages over days and act when something changes, the shape of an AI coworker that owns a recurring job end to end.
Gartner expects agentic AI to resolve 80% of common service issues without a human by 2029. Adoption is following: Deloitte forecasts that 25% of gen-AI companies will pilot agents in 2025, rising to 50% by 2027.
The bottleneck is reliability. Only 30% of gen AI pilots reach full production, by Deloitte's count. Models keep improving at planning and language; the harder problem sits in the web layer under them, reaching real pages, staying logged in, and finishing multi-step work without breaking.
That's the gap TinyFish closes. Give its Web Agent a goal and a URL, and it plans, navigates, signs in, works through the steps, and returns a result. It's benchmarked on task completion, the metric that decides whether a workflow finishes or stalls.
FAQs
What is the difference between generative and agentic workflows?
Generative workflows produce content from a prompt. Agentic workflows pursue a goal by taking actions and using tools across multiple steps.
Can an LLM or a RAG system get fresh web data on its own?
No. A language model works from a fixed training snapshot, and retrieval only reflects what's already in its index. Getting current data from live pages, especially pages behind navigation or a login, takes a web agent that operates the page.
