How to create autonomous AI workflows for SMEs today
Why autonomous AI workflows are critical for SMEs
An autonomous workflow is a system that can:
- Plan tasks, call the appropriate APIs, and iterate without human intervention.
- Adapt to incoming data, continuously improving its prompts and actions.
- Operate 24/7, reducing errors and response times.
The result? Greater efficiency, lower operating costs, and the ability to focus on higher-value activities.
The latest AI tools for autonomous agents
OpenAI has launcheddots, persistent agents powered by GPT-6 Astra, each with its own cloud computer. Each dot maintains state, executes code, and interacts with external tools natively.
H Company has releasedHolo4, an open-weight family of computer-use models that can click, write code, and call tools across desktop, web, Android, and APIs. Holo4 is ideal for tasks requiring interaction with user interfaces.
Google Cloud AI Research has open-sourcedRRSI, a framework that enables LLM agents to autonomously rewrite their prompts, tool-calls, and memory while keeping model weights unchanged. RRSI is perfect for continuous experimentation.
Practical example: an automated invoicing workflow
Imagine you want to create a system that extracts data from an invoice PDF, validates the fields, creates an accounting record, and sends an email notification. Here’s a minimal example using OpenAI dots and a Python interface:
import openai
from pydantic import BaseSettings
# 1. Configure your dot (persistent)
dot = openai.Dot(
model="gpt-6-astra",
tools=[{"type": "function", "function": {"name": "extract_fields", "parameters": {"type": "object", "properties": {"text": {"type": "string"}}}}}]
)
# 2. Extraction function (mock)
async def extract_fields(text: str) -> dict:
# In production, use an OCR + NLP model
return {"invoice_id": "INV-001", "amount": 1250.00, "date": "2026-09-15"}
# 3. Workflow
async def create_invoice_workflow(pdf_path: str):
# Read the PDF (mock)
raw_text = read_pdf(pdf_path)
data = await extract_fields(raw_text)
# Save to your ERP (mock)
await save_to_erp(data)
# Send notification
await send_email_alert(data)
return {"status": "done", "data": data}
# Execute
result = await create_invoice_workflow("fattura_001.pdf")
print(result)Practical example: 24/7 customer support with Holo4
Holo4 excels at interacting directly with UI and APIs. Suppose you want to build a chatbot that checks order status on an e-commerce site:
# Example with Holo4 (pseudo-code)
from hcompany import Holo4Agent
agent = Holo4Agent(weights="Holo4-v1", tools=[
{"name": "login", "endpoint": "https://shop.api/auth"},
{"name": "get_order_status", "endpoint": "https://shop.api/orders/{id}"},
])
async def customer_support_flow(user_id: str, order_id: str):
# The agent authenticates and retrieves the status
await agent.login(user_id=user_id)
status = await agent.get_order_status(order_id)
# Send a natural reply to the user
reply = await agent.generate_reply(
f"Your order {order_id} is currently {status}."
)
return replyBecause Holo4 can click, type, and call APIs, it can handle flows involving legacy or complex interfaces as well.
How to build an autonomous workflow step by step
1. Define goals and map processes
Identify a repetitive process (e.g., customer onboarding, invoicing, IT support). Write a high-level flowchart.
2. Choose the right agent
- Usedotsif you need persistence and code execution capabilities.
- ChooseHolo4for tasks requiring UI interaction.
- AdoptRRSIif you want the agent to autonomously improve its prompts.
3. Integrate with existing tools
Map the required APIs or endpoints and configure permissions. Low-code tools like Zapier or n8n can serve as orchestration layers for initial prototypes.
4. Design prompts and tool-calls
Write clear prompts that describe the role, context, and allowed actions. Use function-calling to delegate specific tasks to tools.
5. Test, monitor, and iterate
Run A/B tests, monitor errors, and use RRSI to continuously optimize the agent.
Common mistakes and how to avoid them
- Agent too generic:Limit the scope of action with domain-specific prompts.
- Neglecting permissions:Always verify that the agent can access the required endpoints.
- Data maintenance:Keep logs of interactions to train custom models if needed.
- Relying completely on automation:Maintain human oversight for critical decisions.
Key takeaways and concrete actions
- Choose an agent: start with an OpenAI dot for logic, integrate Holo4 for UI interaction.
- Write clear prompts and use function-calling; test with real data.
- Implement a monitoring cycle: capture errors, gather feedback, and use RRSI to improve prompts.
- Document each step in a technical reference sheet to scale the workflow to other departments.