Can my AI assistant talk to my friends?

So, what should my assistant do first?
Before even giving it a job, I had to name it. I chose the name Archi because it feels simple, human, and quietly powerful. It’s short for architect because that’s what I want this assistant to be: a builder, a planner, and a thinker.

The idea is simple. Every time I find myself doing something repetitive, messy, or multi-step, I’ll ask: “Can Archi do this for me?” If the answer is yes, I’ll build it.

Reuse and Composition

Not everything I build for Archi is worth keeping. So I have one rule: Every feature must be reusable and composable. It should work across multiple use cases and ideally integrate with other tools. This rule keeps Archi focused, and it keeps me focused too.

The first use case: Talking to my friends

I’m curious what my close friends think about AI assistants. If they could have one like Archi, what would they want it to do? Normally, I’d call them or send a Google Form. But calls are time-consuming, and forms are boring. Worse, they often don’t give me the depth of data I need.
So I had an idea: what if Archi could chat with them directly, ask the right questions, follow up when needed, and deliver their answers back to me?

Why This Feature Matters

At first glance, it’s just a chat-based survey. But actually, it’s a reusable data collection system that could serve many roles.
As I started listing use cases, I had a surprising realization: This system might become the core of Archi itself.

Why? Because every time I give Archi a new mission, it will need to understand what I want, and that means collecting the right information.

This tool won’t just collect feedback from friends. It can:
- Of course, clarify tasks and gather context directly from me

- Collect product feedback from users

- Pre-screen hiring candidates

- Interview users for research

It’s not just a chatbot, it’s a data collector with smart follow-ups. So yes, I’m building it.

How It Works

Here’s the basic flow:

flowchart TD
A[You open chat with Archi] --> B[Describe the mission]
B --> C{Does Archi understand?}
C -- No --> D[Archi asks follow-up questions]
D --> B
C -- Yes --> E[Archi generates a plan]
E --> F[You confirm the plan]
F --> G[Archi creates a shareable link]
G --> H[You send the link to a friend]
H --> I[Friend chats with Archi]
I --> J[Archi collects structured responses]
J --> K[Archi saves structured JSON to database]
J --> L[Archi generates conversation summary]
L --> M[Highlights key extractions]

Technical Breakdown

Archi's new super power: data_collector

This tool collects structured information from people via chat. It follows specific instructions, adheres to a maximum question count, and outputs structured data, a conversation summary, and key extractions.

The tool definition will look like this:

{
  "name": "data_collector",
  "description": "A conversational tool that collects structured information from a person by asking intelligent questions and follow-ups. It adapts to the user's responses, stays within a question limit, and returns structured output with summary and highlights.",
  "input": {
    "mission_description": "string — Human-readable description of the goal (e.g. 'Understand user needs for an AI assistant')",
    "final_goal": "string — What the assistant is trying to achieve (e.g. 'Extract 3-5 features each person wants most')",
    "instructions": "string — Guidelines for tone, style, or behavior (e.g. 'Be concise, avoid small talk')",
    "max_questions": "integer — Maximum number of questions allowed in the conversation",
    "response_schema": "object — A JSON schema defining the expected structure of final responses"
  },
  "output": {
    "responses": "object — A structured object that fits the given response_schema",
    "summary": "string — A natural-language summary of the conversation",
    "key_highlights": "array — A list of key insights, themes, or decisions extracted from the conversation"
  },
  "constraints": {
    "respect_max_questions": true,
    "avoid_chitchat": true,
    "handle_uncertainty": "Ask clarifying questions if the intent or answers are unclear",
    "terminate_early": "If all required data is collected before hitting the question limit, end the session"
  }
}

Database Tables

CREATE TABLE missions (
  id SERIAL PRIMARY KEY,
  description TEXT NOT NULL,
  final_goal TEXT NOT NULL,
  prompt TEXT,
  max_questions INTEGER,
  tone VARCHAR(50),
  response_schema JSONB,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE chats (
  id SERIAL PRIMARY KEY,
  chatable_type VARCHAR(50),
  chatable_id INTEGER,
  mission_id INTEGER REFERENCES missions(id),
  conversation_state VARCHAR(50) DEFAULT 'started',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE chat_messages (
  id SERIAL PRIMARY KEY,
  chat_id INTEGER REFERENCES chats(id),
  role VARCHAR(10) CHECK (role IN ('user', 'archi')),
  body TEXT NOT NULL,
  metadata JSONB,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE chat_summaries (
  id SERIAL PRIMARY KEY,
  chat_id INTEGER REFERENCES chats(id),
  summary_text TEXT,
  key_extractions JSONB,
  generated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Prompt Strategy

Rather than hardcoding one static prompt for each use case, I’m building a prompt generator — a small layer of logic that dynamically creates tailored prompts for Archi.

The generator takes into account:

The mission topic (e.g. “AI assistant features,” “product feedback”)
The respondent type (e.g. friend, customer, job candidate)
The desired output structure (e.g. structured JSON, ranked list, decision criteria)
Tone and constraints (e.g. “be concise,” “ask follow-up questions only if needed,” “stop after 5 turns”)

Why a Prompt Generator?

Each task Archi handles may require a slightly different prompt to guide the assistant’s behavior and maintain consistency in the output format.

For example, asking a friend what AI features they’d want requires a conversational tone and open-ended phrasing. On the other hand, asking a candidate for job preferences might require a more structured, directive approach.

Instead of reinventing the wheel every time, the generator produces the most effective prompt based on inputs.

Prompt Generator Input Schema

{
  "topic": "AI assistant features",
  "audience_type": "friend",
  "desired_output": "structured JSON listing top 3 requested features with short descriptions",
  "max_questions": 5,
  "tone": "curious and friendly"
}

Example Prompt Output

You are Archi, an AI assistant helping me understand what features people would want in their own AI assistant.

You're about to chat with a close friend. Ask them what features they’d want in their ideal personal AI assistant. Make the conversation feel natural — don’t overwhelm them upfront.

Ask follow-up questions if their answers are vague, but keep the conversation focused.

At the end of the conversation, summarize their top 3 requested features in a JSON format like this:

{
  "features": [
    { "name": "Voice-to-text assistant", "description": "Can transcribe notes in real time during meetings." },
    { "name": "Calendar brain", "description": "Understands my schedule and suggests best meeting times." },
    { "name": "Daily recap", "description": "Sends a summary of key events, notes, and tasks." }
  ]
}

Only include features they clearly asked for. You have up to 5 questions. Be thoughtful — not robotic.

Try It Yourself

By the time you read this, the system will already be working. If you'd like to help me shape what Archi becomes, you can try the system yourself. Just answer a few questions below and tell Archi what immediate features you’d want in your own AI assistant.