I’m building Arahi AI, a no-code platform for creating AI agents. We have 2,800+ app integrations.

Here’s what I’ve learned that might help if you’re building in the AI tooling space—or just curious about what goes into a platform like this.

Why AI Agents, Why Now

The automation space has a gap.

Traditional automation tools (Zapier, Make, n8n): Great at moving data between apps. Terrible at handling ambiguity, making decisions, or adapting to edge cases.

Pure AI tools (ChatGPT, Claude): Great at reasoning. No native way to take actions, connect to your apps, or run autonomously.

AI agents sit in the middle: they can reason and act. They handle the messy, judgment-call workflows that rule-based automation chokes on.

That’s the thesis. Here’s the execution reality.

The Integration Challenge

2,800 integrations sounds impressive until you realize what it actually means.

Each integration needs:

• Authentication handling (OAuth, API keys, tokens)
• Action definitions (what can you do with this app?)
• Data mapping (how does output from App A become input for App B?)
• Error handling (what happens when the API changes or rate-limits you?)
• Documentation (so users know what’s possible)

We didn’t build all 2,800 from scratch. We leverage existing infrastructure and focus our custom work on the AI layer—how agents decide which tools to use, in what order, with what parameters.

Lesson: Integrations are a moat, but they’re also maintenance debt. Every API we connect to is a dependency we have to monitor. Choose breadth vs. depth carefully.

The Prompt Engineering Rabbit Hole

When users build agents, they describe what they want in natural language. Our platform has to translate that into reliable, consistent behavior.

This is harder than it looks.

Problem 1: Ambiguity

User says: "Send a follow-up email if they haven’t responded."

Questions the system needs to answer:

• What counts as a response? (Any reply? A positive reply?)
• How long to wait?
• What should the follow-up say?
• What email address to send from?

We’ve learned to build agents that ask clarifying questions rather than guessing. Worse user experience upfront, way better outcomes.

Problem 2: Hallucinated Actions

Early versions would confidently describe actions they couldn’t actually perform. "I’ll update your Salesforce record" when there was no Salesforce connection.

Fix: Grounding. Agents can only propose actions that are actually available in the current workflow. Obvious in retrospect, painful to implement properly.

Problem 3: Inconsistent Output Formatting

When an agent returns data, downstream steps need to parse it. If the AI returns different formats each time, pipelines break.

Fix: Strict output schemas. We force agents to structure their outputs in predictable ways, even though it constrains creativity. Reliability beats cleverness.

Architecture Decisions That Mattered

Synchronous vs. Asynchronous Execution

Some agent tasks complete in seconds. Others take minutes (or hours, if they’re waiting on external triggers).

We run everything async by default. Actions queue, execute, and callback. Users can watch progress or walk away. This was the right call—it handles long-running workflows gracefully.

Human-in-the-Loop by Default

We made a deliberate choice: agents propose, humans approve (for anything consequential).

Full autonomy is tempting for demos, but dangerous for real usage. An agent that auto-sends emails to your customers can go wrong in ways that damage relationships. An agent that drafts and queues for review can only waste time.

User trust is built through predictability, not magic.

Versioning and Rollbacks

Agents evolve. Users tweak prompts, add steps, change conditions. We version everything so they can roll back when something breaks.

This saved us from a lot of support tickets.

What Users Actually Build

Expected: Complex, multi-step autonomous agents

Reality: Mostly simple workflows with one smart decision point

Examples:

• "Classify incoming support tickets and route to the right team"
• "Summarize this document and extract action items"
• "Monitor this RSS feed and alert me if anything matches X"

Users want AI that makes one thing easier, not AI that runs their business. We initially over-built for complexity. Now we optimize for "get value in 5 minutes."

Mistakes We Made

Over-explaining in the UI. Early versions had tooltips and guides everywhere. Users found it overwhelming. Now we show less and let them learn by doing.

Building features before validating demand. We spent weeks on a marketplace for agent templates. Usage was low. Should have validated with a simple shared-links system first.

Underestimating edge cases. The happy path is maybe 60% of usage. The other 40% is weird API behaviors, unexpected user inputs, and failures that need graceful handling. We now spend more time on error states than features.

What’s Next

The AI agents space is moving fast. Models are getting better. User expectations are rising. The window to build before incumbents catch up is shrinking.

Our bet: The winners won’t be the platforms with the smartest AI. They’ll be the platforms that make AI usable for people who don’t want to think about AI.

That’s what we’re building toward.