## 1

1. The Business Pain Point: Hosts Aren't Customer Service, but Guests Think They Are

I manage a small five-person team that provides system support for several vacation rental operators. Last year we received a request: what troubled hosts most wasn't cleaning—it was messages.

The specific scenario goes like this: guests ask a pile of questions before and after booking—"How do I get into the parking lot?" "Can I store my luggage early?" "What good food is nearby?" These questions cluster in two time windows: 9 p.m. to midnight, and before 7 a.m. Meanwhile, the host is either sleeping or busy at another property. Slow replies drive up cancellation rates; hiring someone for night shifts costs too much.

We ran the numbers on a manual customer service solution: for three rental properties with roughly sixty inquiries per day, hiring a part-time night-shift agent would cost around four thousand yuan per month—and training costs were high, turnover was large, and answers were inconsistent. One agent says "extra bed available," the next says "no extra bed," and every resulting dispute lands back on the host.

The pain points boil down to three:

1. Uncontrollable response times: Inquiries at night and early morning almost always timed out;
2. Inconsistent answers: Different people's answers drifted on facts, triggering guest complaints;
3. No centralized risk control: Questions involving refunds, deposits, and safety commitments got arbitrary answers from humans.

These three points determined the design focus of our auto-reply AI: not just "reply fast," but "reply accurately, reply with boundaries, reply traceably."

2. Architecture Design: The Three Questions Managers Care About Most

From a management perspective, the design constraints I set for the team weren't about "which model to use," but about answering three questions first:

Who owns the knowledge? Who handles fallbacks? Who handles review?

The corresponding architecture has four layers:

1. Message ingestion layer: Connects to the open APIs or IM channels of each rental platform and normalizes everything into an internal message format. The key design here is message tagging—source channel, property ID, and urgency level travel with the message, so every downstream layer can read them.

1. Intent routing layer (AI-determined): A single lightweight model call performs intent classification, sorting messages into four categories—factual inquiries (auto-reply OK), booking negotiations (auto-reply + cc the host), complaints and safety (straight to a human), and small talk (brief polite reply). This layer is the core of risk control: anything involving refund, deposit, or personal-safety keywords goes directly to the human channel—the AI never touches it.

1. Knowledge-augmented generation layer (RAG): Each property maintains a structured knowledge base (check-in instructions, amenity lists, neighborhood guides). AI answers must be grounded in retrieved knowledge chunks, and each answer carries "source IDs." For questions with no retrieved evidence, the AI can only say "I've logged this; the host will reply as soon as possible"—free improvisation is not allowed.

1. Audit and fallback layer: All auto-replies are persisted, and a daily audit report is generated. Sessions with confidence below a threshold, or where the guest asks the same question twice in a row, are automatically escalated to the host.

3. Key Implementation Steps

Here's the process checklist:

1. Compile a list of high-frequency questions for the three properties (manually distilled from historical chat logs, about 120 items) and define the intent taxonomy;
2. Write structured knowledge documents for each property, with a hard rule of "no evidence, no answer";
3. Build the message ingestion layer and the unified message format, and complete an internal-loop test on one channel;
4. Configure intent routing: build the risk keyword list and define what must be escalated to a human;
5. Connect to an AI API gateway to centrally manage multi-vendor model calls, keys, and usage;
6. Gradual rollout: for the first two weeks the AI only drafts, the host clicks send, and we track the divergence rate between AI drafts and host-edited versions;
7. Once the divergence rate stabilizes, enable auto-send, while keeping the daily reports and spot-check review mechanism;
8. Establish a knowledge base update workflow: when a host changes amenities (e.g., buys a new dryer), a single message triggers a knowledge document update that takes effect the next day.

Step 6 is one managers must insist on: let the AI be an assistant first, an automaton second. The divergence-rate data from the gradual rollout is the best material for convincing hosts to trust the system.

Core routing code sketch (simplified):

async def handle_message(msg):
    intent = await classify_intent(msg.text)   # 意图分类

    if intent.has_risk_keywords(RISK_LIST):    # 退款/押金/安全
        return escalate_to_host(msg)

    if intent.type == "factual":
        chunks = knowledge_base.search(msg.house_id, msg.text)
        if chunks.score < CONFIDENCE_THRESHOLD:
            return mark_pending(msg)           # 无依据，不乱答
        answer = await generate_with_citations(msg.text, chunks)
        audit_log.record(msg, answer, chunks)  # 全量落库
        return auto_reply(msg, answer)

    return escalate_to_host(msg)

4. Why a Unified AI API Gateway Reduces Maintenance Costs

Three months after launch, we made one architectural adjustment: consolidating all model calls into a unified AI API gateway. The reasons were very practical:

Models will change; business code shouldn't have to. We use a large model for factual Q&A and a small model for intent classification, and we later wanted to try newer, cheaper models. If every call site connected directly to each vendor's SDK, swapping one model meant changing code in three places and testing three times. After consolidating to the gateway, a model switch is just a config change on the gateway side—the call addresses and parameter formats in business code stay completely untouched.

Centralized key and permission management. Three people on the team write call code; keys scattered everywhere will eventually cause an incident. The gateway holds the keys and handles billing centrally. As the manager, I can see call volume and cost per property and per feature in the backend—no more reconciling a pile of invoices at month's end.

Fallback and rate limiting in one place. When one model provider has service issues, the gateway automatically switches to a backup model; when call volume spikes abnormally, it circuit-breaks automatically. All this logic lives in the gateway layer, invisible to business code.

One-sentence summary: the gateway turns "model selection" from a development problem into a management problem—exactly the division of labor a small team needs most.

5. Results and Lessons Learned

After two months of gradual rollout, we went fully automatic. First-response time for nighttime inquiries dropped from over two hours on average to under one minute; complaints caused by inconsistent answers essentially disappeared; the share of inquiries the AI couldn't answer and escalated to humans stabilized around 15%—and that number became a roadmap for knowledge base updates: whatever category escalates most tells you which knowledge documents need filling in.

The biggest lesson: build the risk boundaries first, then chase reply rates. Covering 85% of routine inquiries with auto-reply is already a win; handing the remaining 15% to humans is far safer than letting the AI bluff its way through.

If you're also evaluating AI integration options for a small team and want to manage multi-model calls through a unified gateway with centralized key and usage control, you can register and try it out at https://api.thistoken.ai/register—move the cost of model management out of your code and into backend configuration.

---

Every example in this post runs with a single API key — get yours at https://api.thistoken.ai/register and start in minutes.