Hi HackerNews! I thought this community might find this interesting.

I recently built an AI agent for a mid-sized leasing office. It handles inbound tenant requests (maintenance requests, scheduling tours, questions on unit availability, etc.).

Initially I had a difficult time improving the agent. My business partner understands the nuances of the tenants' problems and I just write the code. Every time the agent made a mistake, she’d flag it and then I’d try my best to translate her feedback into prompt changes or backend logic updates. She knew exactly how the agent’s behavior needed to change and I was just the middleman. I wanted to make something where she could make those changes herself.

I decided to separate the system into two types of steps:

Inference (judgement) – any step that requires interpretation. Is this a prospective tenant or a current one? What request are they making? Do they seem upset? These steps are written as plain-English instructions that anyone can read and edit.

Function calls (actions) – any step that actually does something. Check unit availability, submit a maintenance ticket, schedule a tour, etc. These are backend functions. Engineers own these.

Now she owns the agents' reasoning and I own the agents' capabilities.

If something goes wrong:

She opens the log

Sees every decision the agent made in plain language

Finds the step that made a mistake

Updates the instruction herself

If she wants the agent to handle something new (say handle pet policy questions), she adds an inference step.

If she wants the agent to be able to do something new, she asks me for a new function call step.

She is now able to update the system immediately when something goes wrong and I can just focus on the code.

I realized that this pattern is not specific to leasing offices at all. It works for any text-processing agent where an LLM interprets text and triggers actions. I’m now using the exact same structure to build a Slack bot for my team that handles scheduling requests and internal ops workflows.

The separation between reasoning (owned by domain experts) and capabilities (owned by engineers) turns out to be reusable across use cases.

Because I kept reusing this structure, I ended up turning it into a small platform called Chainix. It’s basically a drag-and-drop interface for building agent workflows where each step is either:

An editable inference block (plain English)

A function call (code)

It’s been really useful for me when building agents with non-technical people.

If anyone here is building something similar or has any critiques of this approach, I’d genuinely love some feedback.

If you’re curious what I built, it’s at https://chainix.ai.