Coder Legion - Recent posts tagged agent

AI Agents for Business: What They Actually Do (and 3 Ways to Use Them)

Tue, 03 Nov 2026 15:50:00 +0000

An AI agent is useful when a model needs to choose among approved tools or steps based on messy input. That flexibility also creates new failure modes: a plausible but wrong decision, an unnecessary tool call, a permission that is too broad, or an action that is hard to reverse.

Partner disclosure. This guide includes a partner link to n8n Cloud. If you sign up through it, I may earn a commission at no extra cost to you.

What makes an AI agent different

A conventional automation follows rules you define. It can still branch, filter, loop, and make deterministic decisions. An agent adds a model-driven choice, such as deciding which approved tool to use or how to interpret an unstructured request.

A typical agent receives a goal, context, and a limited set of tools. The model chooses a next step, observes the result, and may continue until it reaches a stop condition. It only has the memory, tools, and permissions the system provides, and it does not independently know whether a business action is safe.

The simplest test: if the correct path can be written as stable rules, use a normal workflow. Consider an agent only when useful judgment over unstructured input remains after the rules are defined.

The table below shows how the three differ in practice:

	Chatbot	Automation (n8n / Zapier)	AI Agent
Trigger	Human asks	Event fires	Human or system event
Makes decisions	Within the conversation design	Yes, by explicit rules	Yes, by model choice within limits
Remembers context	Sometimes	Only if state is stored	Only if memory is configured
Uses tools	Sometimes	Fixed tools only	Chooses from available tools
Example	Answers "What are your rates?"	Sends Slack alert on form submit	Reads inquiry, scores fit, drafts reply, logs to sheet

Use a five-part boundary before choosing an agent

Input: define what the agent may read and exclude data it does not need.
Tools: expose only the actions required for the task. Prefer read-only access during testing.
Budget: cap model calls, tool calls, runtime, and the number of loops.
Approval: require a person before sending, publishing, paying, deleting, or changing a customer record.
Recovery: log the input, decision, tool result, and final state so a failed run can be inspected without guessing.

If you cannot define those boundaries, the process is not ready for an agent. Start with a read-only assistant or a fixed workflow that prepares a draft for review.

3 real ways to use AI agents in a small business

1. Lead qualification agent

The most common first use case. A lead lands in your inbox. An AI agent reads it, scores the fit against your ideal customer profile, drafts a first reply, and logs the inquiry to a Google Sheet or CRM with a status tag.

The simplest version is manual and read-only: paste test inquiries into a project with a short qualification rubric and compare the output with a person's decision. A connector or background workflow is a later step, after the rubric works and permissions are understood.

A more complete version runs in n8n: form submission triggers the workflow, an AI node reads the inquiry and returns a JSON object with a score, intent category, and a draft reply. The workflow logs to a sheet, notifies you in Telegram or Slack, and optionally sends the draft for your review before sending.

The practical result is a scored, categorized, pre-drafted queue that a person can review. The original inquiry remains the source of truth.

Measure the result with your own baseline: median time to first human review, percentage of leads categorized correctly, edits per draft, missed urgent inquiries, and total model cost. Do not assume time savings before the review work is counted.

2. Operations assistant

This one runs without any human trigger. The agent starts on a schedule (8 AM daily), checks the status of whatever systems you care about, pulls together a short digest, and sends it to a chat channel.

What goes into the digest depends on your business. It might be: new leads since yesterday, open support tickets, a summary of overnight form submissions, or a flag if any watched metric crossed a threshold.

The difference from a regular n8n reporting workflow is that the agent can read unstructured content: email subjects, form text, support messages. It summarizes rather than just counts. A standard automation workflow can count rows and fire a Slack message. An agent can read ten inquiry summaries and tell you which three look like good fits.

For a small team or solo operator, this can reduce the morning ritual of opening several tools. Keep links to the underlying records in the digest, and track omissions and false priorities during a trial period.

3. Hermes Agent: an advanced self-hosted option

The two examples above can be built with managed tools. This one is different.

Hermes Agent is an open-source project from Nous Research. Its current documentation describes messaging gateways for Telegram, Discord, Slack, WhatsApp, Signal, and email, plus built-in and optional persistent memory. Self-hosting gives you more control, but it also makes you responsible for credentials, updates, backups, model access, logs, and tool permissions.

Hermes also supports skills and scheduled jobs. Its cron documentation warns that scheduled jobs start in a fresh agent session, so each prompt must contain the context the job needs. Total cost is not only the VPS: add model usage, external tools, backups, monitoring, and the time required to maintain and secure the system.

The full case study on how Hermes is set up, what broke during installation, what it costs to run, and what persistent memory looks like in practice is now live: Hermes Agent: Self-Hosted AI Assistant with Persistent Memory and Telegram.

This direction makes sense only when the business needs persistent, self-hosted tool use and has someone capable of operating it. A managed assistant or a fixed workflow is safer for a first experiment.

When NOT to use an agent

Not everything needs an agent, and overshooting the complexity is a real failure mode.

If a task always follows the same fixed path with no decisions involved, a regular n8n or Zapier workflow is better. It is cheaper to run, easier to debug, and easier for someone else to maintain. An agent adds value when there is genuine ambiguity: when the right action depends on what the content actually says.

If a task takes ten seconds in Zapier, do not build an agent for it.

Agents also require more care around quality control. A workflow either runs or fails. An agent produces output that can be plausible but wrong. Any agent touching customer-facing content or financial records needs a human review step, at least until you have seen enough output to trust the pattern.

For customer-facing email, that review should be an explicit state rather than a note in the prompt. This n8n human approval pattern for AI email shows how to store the draft, collect an edit or decision, expire unanswered requests, and allow only one send.

The right question is not "can an AI agent do this?" but "does this task actually involve decisions that require judgment?" If the answer is yes, an agent is worth considering. If the answer is no, keep it simple.

What to build first

For most small businesses, start with a fixed intake workflow that stores every inquiry and alerts a person. Add AI only to classify the record or prepare a draft, with an explicit approval state before anything is sent.

A read-only operations digest can be the second step once you have measured classification quality. A self-hosted persistent agent is a later infrastructure choice, not the default upgrade path.

Keep the first trial narrow enough to review every output. Expand access only after the logs show what the system does with normal inputs, missing data, ambiguous requests, and tool failures.

Sources

n8n referral

Want to build your first AI agent workflow?

I may earn a commission if you sign up through this link, at no extra cost to you.

Try n8n Cloud

Know what you want to automate but not sure if it needs an agent?

Send me a short description of the task. I will tell you whether an agent, a standard workflow, or neither is the right fit, and what a practical first version would look like.

Get the map

Originally published on FloxoLab.

Automate Lighthouse Audits with AI Agents: What Chrome DevTools Means for Agencies

Tue, 28 Jul 2026 00:32:22 +0000

Chrome has documented how coding agents can run Lighthouse audits inside Chrome DevTools for agents. Instead of grepping a repository for vague performance clues, the agent loads the page you care about and measures accessibility, SEO, best practices, and agentic browsing against live runtime behaviour. That loop is better for fixing a checkout UI on a local server than another round of static guessing from file names alone.

Agencies should treat this as a development tool, not a finished monitoring programme. A Lighthouse AI agent can catch colour contrast failures or missing meta tags while a developer still has the branch open. It does not replace scheduled tests across forty client sites, budget thresholds, or alerts when a theme deploy regresses Largest Contentful Paint overnight. The sections below separate what Chrome’s agent workflow does well from what multi-tenant PageSpeed monitoring still has to own.

What a Lighthouse AI agent measures in Chrome DevTools

Chrome’s documentation groups agent-driven Lighthouse work into four categories. Accessibility covers screen-reader readiness and related checks such as contrast and ARIA labelling. SEO covers technical discoverability signals search engines need to find and understand the page. Best practices covers modern web hygiene: HTTPS usage, console errors, deprecated APIs, and similar technical standards. Agentic browsing covers how far AI assistants can understand and interact with the site, which sits beside Core Web Vitals work rather than replacing it.

The useful claim is runtime evidence. The agent is not inventing a checklist from file names. It triggers Lighthouse against a page that is actually visible in Chrome, including local development servers and HTML opened through the file:// protocol. Staging URLs count the same way. A coding agent can verify a UI change on localhost before anyone merges, which is where agencies often lose days when accessibility and technical SEO fail only after client UAT.

Local, staging, and file:// support for Chrome DevTools agents

Chrome states that the agent can audit any page visible in the browser. That includes local development servers and local HTML files. For agency teams, that means you can run a Lighthouse AI agent against a feature branch without waiting for a public staging hostname. Keep authentication and feature flags in mind: a logged-in staging route can look healthy while the anonymous production path still fails SEO or accessibility checks.

Chrome also warns about browser behaviour during audits. The page may resize or reload while Lighthouse simulates different devices. Anyone pairing an agent with a shared staging tab should expect brief disruption. Treat agent audits as intentional lab sessions, not something you leave running on a client demo screen without warning.

Prompts for a Lighthouse AI agent: accessibility, SEO, and best practices

Chrome’s examples are short enough to paste into a coding agent that already has DevTools agent tooling. They map cleanly to delivery habits agencies already use. Keep the prompt, the failing audits, and the re-run result in the ticket so the fix is reviewable after the chat window closes.

How to improve accessibility with a Lighthouse AI agent

Prompt: “How can I improve accessibility on this page as measured by Lighthouse?” The documented behaviour is a mobile formFactor audit that surfaces issues such as insufficient colour contrast or missing ARIA labels, then proposes concrete code fixes. That pass earns its keep when a designer ships a new badge colour that still looks fine to sighted reviewers on a calibrated monitor. Ask for the failing audit IDs in the pull request so review does not depend on chat history alone.

How to catch technical SEO blockers before launch

Prompt: “According to Lighthouse audit, how can I improve this page for better discoverability in search?” The agent looks for missing meta tags, canonical links, or weak descriptive text and can offer source updates. Catching those blockers in staging is cheaper than explaining a soft indexing story after launch. Pair the audit with the templates that matter commercially (product, pricing, checkout), not only the marketing homepage the agent happens to have open.

How to validate best practices on local and staging

Prompt: “Does my site follow best practices as measured by Lighthouse?” The audit reviews HTTPS, console errors, and deprecated API calls. Agencies often skip this pass because the design looks finished. Console noise and mixed content still show up in client QA and burn trust in the report pack.

When to run a full mobile and desktop Lighthouse audit

Prompt: “Run a full Lighthouse audit of my site, in mobile and desktop, and suggest improvement areas and possible fixes for any problems you find.” Chrome notes that agents with source context may suggest code fixes, and agents with broader context may also suggest server or backend configuration changes. Treat backend suggestions as hypotheses for your platform team, not as automatic production changes. Re-run after the patch so the conversation ends on measured results, not on a single hopeful pass.

None of these prompts invents a new quality bar. They attach an existing Lighthouse run to the agent’s conversation so the next patch is grounded in failing audits rather than guesswork. If the agent cannot see the page in Chrome, fix the browser connection first; no prompt compensates for an empty viewport.

Lighthouse agentic browsing versus Core Web Vitals reporting

Agentic browsing is the category that often confuses stakeholders. It is not another 0–100 Performance score. It asks whether assistants can understand and interact with the page: tool registration patterns such as WebMCP, agent-oriented accessibility, layout stability that affects programmatic clicks, and related discoverability signals. We already covered how experimental Lighthouse agentic browsing scoring works, including fractional pass ratios and WebMCP observation, in Lighthouse Agentic Browsing: How to rank in chatbots.

For agencies, the operational rule is simple. Keep Core Web Vitals and PageSpeed Performance scores as the client-facing performance language you already report. Use agentic browsing audits as an early research signal when a product site exposes agent tools or when a client asks whether AI assistants can use their flows. Do not promote experimental pass ratios into a retainer KPI until the standard and your tooling story are stable. Chrome’s agent docs put agentic browsing in the same Lighthouse family as accessibility and SEO, which is correct for developers, but buyers still buy predictability on Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift first.

If you need the math behind how Lighthouse turns raw timings into a Performance category score, Chrome documents the scoring model, and we have a dedicated Watcher explainer scheduled for that calculation path. The agency takeaway for agent workflows is narrower: a coding agent can improve category scores by fixing the failed audits it sees, but those lab scores are still synthetic. Field Core Web Vitals remain a separate truth.

Why one AI coding agent Lighthouse run is not portfolio monitoring

A successful agent session looks like this: open the priority URL on staging, run accessibility and SEO audits, apply fixes, re-run, then merge when the failures that blocked the ticket are cleared. That loop is useful. It is also a single device, a single URL, a single moment in time, and usually a single human watching the tab.

Agency failure modes live elsewhere. A plugin update lands on Friday across twelve WordPress sites. A Shopify theme ships a new app block that only hurts mobile Interaction to Next Paint on product templates. A marketing team adds a tag manager container that never appears on the developer’s localhost build. Spot PageSpeed Insights runs and agent audits both miss that class of regression unless someone remembers to re-check every affected URL after every change. We unpacked when manual checks stop scaling in PageSpeed Insights vs Automated Monitoring: When Manual Checks Aren't Enough.

Synthetic versus field data adds another split. Agent-driven Lighthouse is synthetic lab evidence, closer to a controlled PageSpeed Insights run than to Chrome UX Report percentiles. Knowing when to lean on lab schedules versus real-user monitoring is a separate decision; see When to Use Synthetic vs Real User Monitoring for Performance. Use the agent to fix what is broken in the environment you control, then keep scheduled synthetic tests on production priority URLs so regressions after merge still raise an alert.

How agencies combine Chrome DevTools agents with scheduled PageSpeed monitoring

A practical split that matches how delivery teams already work:

During build. Use a Lighthouse AI agent on local and staging for accessibility, technical SEO, best practices, and optional agentic browsing when the product exposes agent tools. Paste Chrome’s example prompts and keep the failing audit list in the pull request.
At release. Re-run the same priority templates on the staging hostname the client will accept, still with the agent or a manual Lighthouse pass if the agent tooling is unavailable.
After release. Rely on scheduled PageSpeed Insights or Lighthouse runs across the portfolio, with budgets and alerts on the URLs that earn revenue or retention. That is the layer Apogee Watcher is built for: multi-tenant schedules, history, and client-ready reporting without asking a developer to babysit Chrome tabs.

Layer, do not replace. Coding agents do not remove the need for continuous monitoring any more than Lighthouse CI removes the need for field Core Web Vitals. They shorten the time from “UI changed” to “measurable defect named.” Monitoring shortens the time from “production changed” to “someone on the account knows.” If you want a fast baseline before you wire schedules, run a free domain PageSpeed check to see multi-page lab results for a hostname. When you are ready to put priority URLs on a recurring cadence, follow Getting Started with Apogee Watcher: A Step-by-Step Setup Guide.

Common mistakes with Chrome DevTools agent Lighthouse audits

Treating a green agent pass as production proof

Local data, auth walls, and feature flags differ from what real users and the Chrome UX Report show. A clean mobile audit on staging can still leave desktop production amber on Interaction to Next Paint. Ship the fix, then confirm on the production URL with the same device form factor you care about in the retainer report.

Auditing only the homepage

Agents will audit whatever page is loaded. Homepages are convenient and often wrong for ecommerce and SaaS work. If checkout, pricing, or login is where money and trust live, load those routes before you ask for a Lighthouse AI agent run.

Ignoring audit disruption on shared environments

Resize and reload behaviour can interrupt demos and live editing. Chrome documents that Lighthouse may change viewport size while simulating devices. Schedule agent audits the same way you schedule Lighthouse CI: on purpose, not mid-call with a client watching the same tab.

Confusing Lighthouse agentic browsing with SEO rankings

Agentic browsing audits help you understand assistant interaction readiness. They are not a substitute for crawlability, content quality, or Core Web Vitals programmes you already sell. Keep the category in research notes until you and the client agree what a pass ratio means commercially.

Skipping history after the coding agent finishes

An agent conversation disappears when the chat ends. Agencies need trend lines and budget breaches stored against the site record. Without history, last week’s “we fixed contrast” claim is hard to prove in a monthly review, and the next developer repeats the same audit from scratch.

FAQ

Does a Lighthouse AI agent replace PageSpeed Insights?No. The agent uses Lighthouse categories in a developer workflow inside Chrome. PageSpeed Insights remains a common lab entry point for stakeholders, and scheduled PageSpeed Insights or Lighthouse API runs remain how you watch many URLs over time. Use the agent to fix; use monitoring to watch. For the wider comparison of spot checks versus automation, see our PageSpeed Insights versus automated monitoring guide.

Can coding agents audit pages that are not on the public internet?Yes, within Chrome’s stated support: any page visible in the browser, including local servers and file:// HTML. That is one of the strongest reasons to use agents during build rather than waiting for a public staging URL. Confirm the same checks later on the hostname clients and crawlers actually hit.

Should we report agentic browsing scores to clients every month?Only if you have agreed what the category means and how experimental it still is. Most retainers should keep leading with Core Web Vitals and clear lab Performance trends, then mention agentic browsing when a product roadmap or assistant integration makes it relevant. Point curious clients at the agentic browsing scoring explainer before you put pass ratios on a dashboard.

Where do budgets and alerts fit if developers already run agent audits?Budgets and alerts cover the gap after merge: unexpected third-party tags, plugin updates, and content changes that never open a coding agent session. Agent audits reduce defects entering the branch. Monitoring reduces defects lingering in production unnoticed. Set budgets on the same priority URLs you used in the agent session so the definition of “good” does not drift between tools.

Chrome DevTools for agents makes Lighthouse a first-class tool in coding-agent workflows. Accessibility, SEO, best practices, and agentic browsing can be measured on the page under change, including local and staging hosts. Agencies win when they adopt that loop for delivery quality and keep scheduled, multi-site PageSpeed monitoring for everything that happens after the pull request merges. Start with Chrome’s documented prompts on your next UI branch, then put the same priority URLs on a schedule so the fix stays fixed.

Just have listed my Scrape Agent MCP :-)

Wed, 03 Jun 2026 21:59:33 +0000

I built a pay-per-use web scraping API with Claude's help — free to try, $0.01/call after that

I'm a designer learning to code, and over the past few months I've been building my first real API with Claude as my coding partner. The result is Scrape Agent — a web scraping API built on the x402 micropayment protocol.

What it does:

Extract clean text, links, HTML, or metadata from any public URL. No API key, no subscription, no account needed. You just call the endpoint and pay $0.01 USDC on Base per scrape — or nothing if you're just testing.

How Claude helped:

Honestly, I couldn't have built this without Claude. I had zero backend experience. Claude walked me through every step — Express.js setup, x402 middleware integration, OpenAPI spec, the .well-known/x402 manifest for agent autodiscovery, deployment on Google Cloud. It was a real pair-programming experience across many sessions.

Why x402:

The x402 protocol means AI agents can call and pay for the API autonomously — no human in the loop, no billing account, just wallet-to-wallet USDC micropayments. Perfect for agent pipelines that need web data on demand.

Free to try:

The endpoint returns a valid 402 response you can inspect without paying anything. Full OpenAPI spec at /openapi.json.

Website: https://scrapeagent.xyz

MCP version (for Claude/Cursor): https://scrape-agent-mcp.vercel.app

Happy to answer any questions — especially from other non-coders trying to build in this space. Still learning every day.

Understanding CopilotKit Agent Patterns: A Comprehensive Guide

Sat, 25 Apr 2026 06:55:22 +0000

What is the CopilotKit Agent Patterns Skill?

The CopilotKit Agent Patterns skill is a comprehensive framework designed to help developers build AI agents that seamlessly integrate with CopilotKit’s ecosystem. This skill provides 20 well-defined rules across five critical categories, offering guidance on everything from agent architecture to generative UI emission.

Why This Skill Matters

When building AI agents that need to interact with CopilotKit’s runtime and frontend components, developers face numerous challenges around state management, event streaming, and user interaction patterns. This skill addresses these challenges by providing battle-tested patterns that ensure reliable agent behavior and smooth integration with CopilotKit’s AG-UI protocol.

Key Components of the Skill

Five Priority Categories

The skill organizes its 20 rules into five priority categories, each with a specific prefix to help developers quickly identify the type of guidance they need:

Agent Architecture (CRITICAL) – Rules prefixed with architecture-
AG-UI Protocol (HIGH) – Rules prefixed with agui-
State Management (HIGH) – Rules prefixed with state-
Human-in-the-Loop (MEDIUM) – Rules prefixed with hitl-
Generative UI Emission (MEDIUM) – Rules prefixed with genui-

When to Apply These Patterns

The skill is particularly valuable when you’re:

Designing agent architecture for CopilotKit integration
Implementing AG-UI protocol event streaming
Managing state synchronization between agent and frontend
Adding human-in-the-loop checkpoints to agent workflows
Emitting tool calls that render generative UI in the frontend

https://github.com/openclaw/skills/tree/main/skills/generaljerel/copilotkit-agent-patterns/SKILL.mdThe

How to create a robust AI agent in less than 10 lines of TypeScript

Thu, 09 Apr 2026 10:54:35 +0000

Your AI agent crashes after 2 minutes of work. You lose everything. It doesn't have to be this way.

I've seen it happen in every production AI project.

You build a beautiful agent. It works perfectly in local. You ship it.
Then it runs for 90 seconds, hits a timeout, crashes — and all context is gone.
Your user stares at a spinner. Your logs show nothing useful.

The problem isn't your LLM. It's your architecture.

AI agents are stateful, long-running processes. And we've been treating them like stateless HTTP handlers.

Let me show you how to fix this in 10 lines.

The Problem: Agents Are Ephemeral by Default

// Standard agent — everything lives in RAM
const agent = new StreamingToolAgent({ goal: 'Research assistant' }, llm)
const result = await agent.run('Research the top 10 AI papers of 2025')
// If this crashes at step 8/10... you restart from zero.

The issue is that AI agent state lives only in memory. The moment the process dies — OOM, timeout, deployment, network blip — you lose everything.

The Solution: `@orka-js/durable`

import { DurableAgent, MemoryDurableStore } from '@orka-js/durable'
import { StreamingToolAgent } from '@orka-js/agent'
import { OpenAIAdapter } from '@orka-js/openai'

const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! })
const agent = new StreamingToolAgent({ goal: 'Research assistant', tools: [] }, llm)
const store = new MemoryDurableStore()
const durable = new DurableAgent(agent, store, { maxRetries: 3 })

// That's it. Your agent is now durable.
const job = await durable.run('job-001', 'Research the top 10 AI papers of 2025')
console.log(job.status)  // 'completed'
console.log(job.result)  // The full research

That's literally 10 lines. Let me break down what just happened.

What `DurableAgent` Actually Does

1. Every job has a persistent ID

const job = await durable.run('job-001', 'Research AI papers')

The job-001 identifier is the key insight. If this job already ran and completed, calling run('job-001', ...) again returns the cached result immediately — no LLM call made.

This is idempotency. It's the foundation of reliable distributed systems, now applied to AI agents.

2. Automatic retry with backoff

const durable = new DurableAgent(agent, store, {
  maxRetries: 3,
  retryDelayMs: 2000, // wait 2s between retries
})

If your agent fails (rate limit, network error, LLM timeout), DurableAgent retries automatically. No try/catch soup. No manual retry loops.

3. Human-in-the-loop: pause and resume

This is where it gets genuinely powerful.

// Start a long research job
const job = await durable.run('analysis-42', 'Analyze Q4 financial reports')

// Pause it — maybe you need human approval before continuing
await durable.pause('analysis-42')

// Hours later, after your manager reviews the intermediate output...
const resumed = await durable.resume('analysis-42')
console.log(resumed.result)

You can build approval workflows where an agent pauses waiting for a human decision, then resumes exactly where it left off. No state reconstruction. No prompt re-injection hacks.

Production: Switch to Redis in One Line

MemoryDurableStore is great for local dev. For production:

import { RedisDurableStore } from '@orka-js/durable'
import { createClient } from 'redis'

const redis = createClient({ url: process.env.REDIS_URL })
await redis.connect()

const store = new RedisDurableStore(redis) // <- one line change
const durable = new DurableAgent(agent, store, { maxRetries: 3 })

Your agent jobs now survive:

Server restarts
Deployments
OOM crashes
Cloud instance preemptions

Scheduled Agents: Cron for AI

One more thing. You can schedule an agent to run on a cron:

const durable = new DurableAgent(agent, store)

// Run every day at 9am
durable.schedule('daily-briefing', '0 9 * * *', 'Generate the daily news summary')

No cron infrastructure to set up. No separate worker process. Just declare it and forget it.

Stream Events While Persisting State

If your agent supports streaming (it should), DurableAgent preserves it:

const stream = durable.stream('job-002', 'Write a full market analysis')

for await (const event of stream) {
  if (event.type === 'text') process.stdout.write(event.content)
  if (event.type === 'tool_call') console.log('Using tool:', event.name)
  if (event.type === 'done') console.log('Job saved:', event.jobId)
}

The user sees a streaming response. The job state is persisted in the background. Best of both worlds.

The Mental Model Shift

Before	After
Agent = function call	Agent = persistent job
Failure = start over	Failure = resume from checkpoint
Long tasks = scary	Long tasks = no problem
Human review = impossible	Human review = pause/resume
Cron = separate infra	Cron = built-in

Get Started

npm install @orka-js/durable @orka-js/agent @orka-js/openai

import { DurableAgent, MemoryDurableStore } from '@orka-js/durable'
import { StreamingToolAgent } from '@orka-js/agent'
import { OpenAIAdapter } from '@orka-js/openai'

const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! })
const agent = new StreamingToolAgent({ goal: 'Assistant', tools: [] }, llm)
const durable = new DurableAgent(agent, new MemoryDurableStore(), { maxRetries: 2 })

const job = await durable.run('my-first-durable-job', 'Hello, world!')
console.log(job.status, job.result)

That's it. Your agents are now production-grade.

Docs: orkajs.com

If this solved a problem you've had, share it

How to Build a Durable AI Agent in 10 Lines of TypeScript

Mon, 06 Apr 2026 08:18:08 +0000

Your AI agent crashes after 2 minutes of work. You lose everything. It doesn't have to be this way.

I've seen it happen in every production AI project.

The problem isn't your LLM. It's your architecture.

AI agents are stateful, long-running processes. And we've been treating them like stateless HTTP handlers.

Let me show you how to fix this in 10 lines.

The Problem: Agents Are Ephemeral by Default

// Standard agent — everything lives in RAM
const agent = new StreamingToolAgent({ goal: 'Research assistant' }, llm)
const result = await agent.run('Research the top 10 AI papers of 2025')
// If this crashes at step 8/10... you restart from zero.

The issue is that AI agent state lives only in memory. The moment the process dies — OOM, timeout, deployment, network blip — you lose everything.

The Solution: `@orka-js/durable`

import { DurableAgent, MemoryDurableStore } from '@orka-js/durable'
import { StreamingToolAgent } from '@orka-js/agent'
import { OpenAIAdapter } from '@orka-js/openai'

const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! })
const agent = new StreamingToolAgent({ goal: 'Research assistant', tools: [] }, llm)
const store = new MemoryDurableStore()
const durable = new DurableAgent(agent, store, { maxRetries: 3 })

// That's it. Your agent is now durable.
const job = await durable.run('job-001', 'Research the top 10 AI papers of 2025')
console.log(job.status)  // 'completed'
console.log(job.result)  // The full research

That's literally 10 lines. Let me break down what just happened.

What `DurableAgent` Actually Does

1. Every job has a persistent ID

const job = await durable.run('job-001', 'Research AI papers')

The job-001 identifier is the key insight. If this job already ran and completed, calling run('job-001', ...) again returns the cached result immediately — no LLM call made.

This is idempotency. It's the foundation of reliable distributed systems, now applied to AI agents.

2. Automatic retry with backoff

const durable = new DurableAgent(agent, store, {
  maxRetries: 3,
  retryDelayMs: 2000, // wait 2s between retries
})

If your agent fails (rate limit, network error, LLM timeout), DurableAgent retries automatically. No try/catch soup. No manual retry loops.

3. Human-in-the-loop: pause and resume

This is where it gets genuinely powerful.

// Start a long research job
const job = await durable.run('analysis-42', 'Analyze Q4 financial reports')

// Pause it — maybe you need human approval before continuing
await durable.pause('analysis-42')

// Hours later, after your manager reviews the intermediate output...
const resumed = await durable.resume('analysis-42')
console.log(resumed.result)

You can build approval workflows where an agent pauses waiting for a human decision, then resumes exactly where it left off. No state reconstruction. No prompt re-injection hacks.

Production: Switch to Redis in One Line

MemoryDurableStore is great for local dev. For production:

import { RedisDurableStore } from '@orka-js/durable'
import { createClient } from 'redis'

const redis = createClient({ url: process.env.REDIS_URL })
await redis.connect()

const store = new RedisDurableStore(redis) // <- one line change
const durable = new DurableAgent(agent, store, { maxRetries: 3 })

Your agent jobs now survive:

Server restarts
Deployments
OOM crashes
Cloud instance preemptions

Scheduled Agents: Cron for AI

One more thing. You can schedule an agent to run on a cron:

const durable = new DurableAgent(agent, store)

// Run every day at 9am
durable.schedule('daily-briefing', '0 9 * * *', 'Generate the daily news summary')

No cron infrastructure to set up. No separate worker process. Just declare it and forget it.

Stream Events While Persisting State

If your agent supports streaming (it should), DurableAgent preserves it:

const stream = durable.stream('job-002', 'Write a full market analysis')

for await (const event of stream) {
  if (event.type === 'text') process.stdout.write(event.content)
  if (event.type === 'tool_call') console.log('Using tool:', event.name)
  if (event.type === 'done') console.log('Job saved:', event.jobId)
}

The user sees a streaming response. The job state is persisted in the background. Best of both worlds.

The Mental Model Shift

Before	After
Agent = function call	Agent = persistent job
Failure = start over	Failure = resume from checkpoint
Long tasks = scary	Long tasks = no problem
Human review = impossible	Human review = pause/resume
Cron = separate infra	Cron = built-in

Get Started

npm install @orka-js/durable @orka-js/agent @orka-js/openai

import { DurableAgent, MemoryDurableStore } from '@orka-js/durable'
import { StreamingToolAgent } from '@orka-js/agent'
import { OpenAIAdapter } from '@orka-js/openai'

const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! })
const agent = new StreamingToolAgent({ goal: 'Assistant', tools: [] }, llm)
const durable = new DurableAgent(agent, new MemoryDurableStore(), { maxRetries: 2 })

const job = await durable.run('my-first-durable-job', 'Hello, world!')
console.log(job.status, job.result)

That's it. Your agents are now production-grade.

OrkaJS is a TypeScript-first framework for building production AI agents. Modular, typed, and provider-agnostic.

GitHub: github.com/orka-ai/orkajs
Docs: orkajs.com
npm: npm install orka-js/<package>

If this solved a problem you've had, share it — other devs are fighting the same battle right now.

Why AI Evaluations Are Essential for Building High-Performance AI Agents

Tue, 24 Mar 2026 23:17:53 +0000

Why AI Evaluations Are Essential for Building High-Performance AI Agents

Artificial intelligence is rapidly transforming industries, from customer service to healthcare, finance, and beyond. As AI agents become more sophisticated, the need to rigorously evaluate their performance has never been greater. AI evaluations are no longer optional—they are a necessity for building effective, reliable, and trustworthy AI agents.

The Growing Complexity of AI Agents

Modern AI agents are expected to handle increasingly complex tasks: understanding nuanced language, making context-aware decisions, and interacting seamlessly with users. This complexity brings new challenges:

Unpredictable behavior: AI agents may produce inconsistent or biased outputs.
Safety concerns: Errors can lead to misinformation, security risks, or even harm.
Performance gaps: An AI that works well in a lab may fail in real-world scenarios.

Without proper evaluations, these issues can go unnoticed until it’s too late.

What Are AI Evaluations?

AI evaluations are systematic assessments of an AI agent’s performance, accuracy, and reliability. They involve testing the agent against a variety of scenarios, metrics, and benchmarks to ensure it meets desired standards. Evaluations can cover:

Functional accuracy: Does the agent produce correct and relevant outputs?
Robustness: How does the agent perform under stress or with unexpected inputs?
Ethical compliance: Does the agent avoid harmful biases or unethical behavior?
User experience: Is the agent intuitive and helpful to end users?

Why AI Evaluations Are Now a Necessity

1. Ensuring Reliability and Trust

Users expect AI agents to be dependable. A chatbot that gives incorrect information or a recommendation system that makes poor suggestions can quickly erode trust. Evaluations help identify and fix these issues before deployment.

2. Mitigating Risks

AI agents can have far-reaching consequences. For example, a faulty medical diagnosis AI or a biased hiring tool can cause real harm. Rigorous evaluations are essential for risk management and compliance with industry regulations.

3. Optimizing Performance

Evaluations provide actionable insights into an AI agent’s strengths and weaknesses. This data-driven approach enables continuous improvement, ensuring the agent evolves with user needs and technological advancements.

4. Meeting Regulatory and Ethical Standards

As governments and organizations introduce AI guidelines, evaluations help ensure compliance. They also promote transparency, making it easier to explain how an AI agent makes decisions.

Best Practices for AI Evaluations

Define Clear Objectives

Before evaluating, establish what success looks like. Are you prioritizing accuracy, speed, user satisfaction, or ethical behavior? Clear goals guide the evaluation process.

Use Diverse Test Scenarios

Test your AI agent with a wide range of inputs, including edge cases and adversarial examples. This helps uncover hidden flaws and ensures robustness.

Measure Multiple Metrics

Don’t rely on a single metric. Combine quantitative measures (like accuracy or response time) with qualitative assessments (such as user feedback or ethical reviews).

Iterate and Improve

AI evaluation is not a one-time task. Regularly reassess your agent as it’s updated or as new use cases emerge.

Real-World Examples

Consider a customer service AI agent. Without evaluations, it might misunderstand complex queries or provide irrelevant answers, frustrating users. By rigorously testing the agent with diverse customer interactions, developers can refine its responses, improve accuracy, and boost satisfaction.

Similarly, in healthcare, an AI that assists with diagnostics must be thoroughly evaluated to avoid misdiagnoses. Evaluations ensure the AI meets clinical standards and protects patient safety.

The Future of AI Evaluations

As AI agents become more autonomous and integrated into critical systems, the role of evaluations will only grow. Emerging trends include:

Automated evaluation tools: AI-driven systems that continuously monitor and test agent performance.
Explainable AI: Evaluations that not only measure outcomes but also clarify how decisions are made.
Cross-disciplinary collaboration: Involving ethicists, domain experts, and end users in the evaluation process.

Conclusion

AI evaluations are no longer a luxury—they are a necessity for building effective, trustworthy, and high-performing AI agents. By systematically assessing and improving your AI, you can deliver solutions that truly meet user needs and stand up to real-world challenges. As the field of AI continues to advance, those who prioritize rigorous evaluations will be best positioned for success.

FAQ

What are AI evaluations?

AI evaluations are systematic assessments of an AI agent’s performance, accuracy, and reliability, ensuring it meets desired standards.

Why are AI evaluations important?

They help ensure reliability, mitigate risks, optimize performance, and meet regulatory and ethical standards.

How often should AI agents be evaluated?

AI agents should be evaluated regularly, especially after updates or when new use cases emerge.

What metrics are used in AI evaluations?

Common metrics include accuracy, response time, user satisfaction, robustness, and ethical compliance.

Can AI evaluations prevent all errors?

While evaluations significantly reduce errors, they cannot guarantee perfection. Continuous monitoring and improvement are essential.

The post Why AI Evaluations Are Essential for Building High-Performance AI Agents first appeared on Insight Ginie.

Coder Legion - Recent posts tagged agent

AI Agents for Business: What They Actually Do (and 3 Ways to Use Them)

What makes an AI agent different

Use a five-part boundary before choosing an agent

3 real ways to use AI agents in a small business

1. Lead qualification agent

2. Operations assistant

3. Hermes Agent: an advanced self-hosted option

When NOT to use an agent

What to build first

Sources

Automate Lighthouse Audits with AI Agents: What Chrome DevTools Means for Agencies

What a Lighthouse AI agent measures in Chrome DevTools

Local, staging, and file:// support for Chrome DevTools agents

Prompts for a Lighthouse AI agent: accessibility, SEO, and best practices

How to improve accessibility with a Lighthouse AI agent

How to catch technical SEO blockers before launch

How to validate best practices on local and staging

When to run a full mobile and desktop Lighthouse audit

Lighthouse agentic browsing versus Core Web Vitals reporting

Why one AI coding agent Lighthouse run is not portfolio monitoring

How agencies combine Chrome DevTools agents with scheduled PageSpeed monitoring

Common mistakes with Chrome DevTools agent Lighthouse audits

Treating a green agent pass as production proof

Auditing only the homepage

Ignoring audit disruption on shared environments

Confusing Lighthouse agentic browsing with SEO rankings

Skipping history after the coding agent finishes

FAQ

Just have listed my Scrape Agent MCP :-)

Understanding CopilotKit Agent Patterns: A Comprehensive Guide

What is the CopilotKit Agent Patterns Skill?

Why This Skill Matters

Key Components of the Skill

Five Priority Categories

When to Apply These Patterns

How to create a robust AI agent in less than 10 lines of TypeScript

The Problem: Agents Are Ephemeral by Default

The Solution: @orka-js/durable

What DurableAgent Actually Does

1. Every job has a persistent ID

2. Automatic retry with backoff

3. Human-in-the-loop: pause and resume

Production: Switch to Redis in One Line

Scheduled Agents: Cron for AI

Stream Events While Persisting State

The Mental Model Shift

Get Started

How to Build a Durable AI Agent in 10 Lines of TypeScript

The Problem: Agents Are Ephemeral by Default

The Solution: @orka-js/durable

What DurableAgent Actually Does

1. Every job has a persistent ID

2. Automatic retry with backoff

3. Human-in-the-loop: pause and resume

Production: Switch to Redis in One Line

Scheduled Agents: Cron for AI

Stream Events While Persisting State

The Mental Model Shift

Get Started

Why AI Evaluations Are Essential for Building High-Performance AI Agents

Why AI Evaluations Are Essential for Building High-Performance AI Agents

The Growing Complexity of AI Agents

What Are AI Evaluations?

Why AI Evaluations Are Now a Necessity

1. Ensuring Reliability and Trust

2. Mitigating Risks

3. Optimizing Performance

4. Meeting Regulatory and Ethical Standards

Best Practices for AI Evaluations

Define Clear Objectives

Use Diverse Test Scenarios

Measure Multiple Metrics

Iterate and Improve

Real-World Examples

The Future of AI Evaluations

Conclusion

FAQ

What are AI evaluations?

Why are AI evaluations important?

The Solution: `@orka-js/durable`

What `DurableAgent` Actually Does

The Solution: `@orka-js/durable`

What `DurableAgent` Actually Does