How We Built Our Own AI-Powered 'Company Brain' to Eliminate Daily Confusion

At Etere Studio, we spent 6+ hours every week answering the same questions: "What did Mario@Acme ask for again?" "Which version are we deploying?" "Did we already bill this sprint?" Not because anyone was lazy. Because information lived in five different places and our brains couldn't keep up.

Here's the thing nobody tells you about running a small software shop: the cognitive overhead is brutal. You're switching between client Slack channels, internal docs, GitHub issues, calendar invites, and email threads. By 3pm, you've lost context three times. By Friday, you're second-guessing decisions you made on Monday.

We tried the usual solutions. Notion wikis that nobody updated. Slack threads that got buried. Friday recap meetings where we'd spend 30 minutes reconstructing what happened on Tuesday. Nothing stuck.

The breaking point came on a Saturday morning. A client sent a follow-up question about a feature we'd discussed two weeks prior. I spent 45 minutes hunting through messages to find the original conversation, only to realize I'd given him slightly different information than what my teammate had said. We looked disorganized. We felt disorganized. We were disorganized.

That weekend, we decided to build what we now call our "company brain."

The Problem: Context Switching Kills Momentum

Before we get into what we built, let's talk about why this problem matters.

In a typical week, we'd handle:

• 4-6 client projects in various stages
• 15-20 feature requests or questions via Slack
• 8-12 internal decisions about architecture, priorities, or hiring
• Countless messages about scheduling, invoices, and logistics

Each of these lived in a different place. Client A's feature request was in their Slack channel. The decision to use Firebase for Client B was in a Google Doc. The invoice status for Client C was in an email thread.

When someone asked "What's the status on that thing?" we had to:

1. Remember which client
2. Remember which project
3. Remember where we discussed it
4. Find the thread
5. Read through to get context
6. Answer

This isn't a 30-second task. It's 5-10 minutes. Multiply that by 20 times per week, and you've lost three hours just retrieving information you already knew once.

And here's the worst part: sometimes you'd retrieve it wrong. You'd conflate details from two different clients. You'd forget the nuance from a follow-up message. You'd give an answer that contradicted what someone else on the team had said.

Our Solution: Four Components That Actually Work

We built a system that listens to our conversations, extracts what matters, and surfaces it when we need it. Not magic. Just well-orchestrated automation.

Component 1: Slack Integration

We built a bot that monitors specific Slack channels (client channels, our internal planning channel). When someone asks a question or makes a decision, it captures the message, the context, and who was involved.

Crucially, it doesn't capture everything. We trained it to recognize decision language ("let's go with", "we should", "the plan is") and question patterns. Random banter gets ignored.

Component 2: Structured Storage

Every captured message gets processed into a structured format:

• Client/project name
• Topic category (feature request, technical decision, logistics)
• Key participants
• Summary in one sentence
• Link back to original thread
• Date

We use a simple Airtable base for this. Could've been Postgres. Could've been Notion. The point is structure, not the tool.

Component 3: AI Summarization

At the end of each day, an AI agent (we use Claude) reads through the day's captures and generates:

• A per-client summary ("Mario@Acme asked about push notifications; we said we'd include it in Sprint 3")
• A team summary ("Decided to delay hiring until Q2; prioritizing existing client work")
• Open questions that need follow-up

These get posted to a dedicated Slack channel every morning at 8am.

Component 4: Instant Retrieval

When someone asks "What's the status on Mario's push notification request?" in Slack, they can mention our bot. It searches the structured database, pulls relevant entries, and responds in-thread with:

• The original decision
• When it was made
• Who was involved
• Link to the full conversation

Response time: under 3 seconds.

What Changed: Real Numbers

We've been running this system for three months. Here's what's different:

Time saved: We tracked "context retrieval time" before and after. Before: ~6 hours per week collectively. After: ~1 hour per week. That's 5 hours back, or 20 hours per month. At our rates, that's roughly $3,000 in billable time.

Consistency improved: We used to have about 2-3 "wait, that contradicts what you said earlier" moments per week. Now it's maybe one per month. Our clients notice. One said we "seem way more organized now."

Decision fatigue reduced: The morning summaries mean we start each day knowing exactly where we left off. No more "what were we working on?" conversations.

Onboarding faster: When we brought in a contractor last month, they could search the bot for "Client X authentication flow" and get the full history in seconds. Normally that would've required 30 minutes of us explaining.

What We Learned: Three Months of Mistakes

This didn't work on the first try. Or the second.

Mistake 1: Over-capturing

Initially, we had the bot capture everything. Every message. Every emoji reaction. The summaries became noise. We iterated to focus only on decisions and questions.

Mistake 2: Wrong storage model

We started with everything in Slack threads. Terrible for retrieval. Moved to Airtable where we could structure and search properly.

Mistake 3: No human verification loop

The AI occasionally misinterpreted sarcasm or captured the wrong decision. We added a simple "verify" step where one person skims the daily captures before they get summarized. Takes 5 minutes.

Mistake 4: Assuming we'd use it

For the first two weeks, nobody mentioned the bot. We'd forget it existed. We fixed this by having it proactively post summaries, not waiting to be asked.

The Tech Stack (For Those Who Care)

• Slack Bolt API for message listening
• Claude API for summarization and question answering
• Airtable for structured storage
• Simple Python script on a cron job for daily summaries
• Hosted on a $12/month DigitalOcean droplet

Total build time: about 30 hours over two weeks. Total cost: ~$50/month (mostly AI API calls).

This isn't cutting-edge technology. It's well-orchestrated boring tools.

You Don't Need to Build This Exact System

Here's what matters: we identified our biggest confusion point ("where is this information?") and solved it.

Yours might be different. Maybe it's "who's responsible for this task?" or "what's our runway?" or "which version of the design is current?"

The pattern is the same:

1. Identify the one question you're tired of asking
2. Figure out where that information lives
3. Build or buy something that surfaces it automatically
4. Iterate until people actually use it

You don't need AI. You don't need fancy tools. You just need to stop accepting "I don't know, let me check" as normal.

Final Thought: AI Is a Tool, Not Magic

We built this because we were frustrated, not because we love AI. The AI part is honestly the least interesting component. What matters is that we structured our information in a way that makes it retrievable.

The AI just reads faster than we do.

If you're dealing with the same kind of cognitive overload—and honestly, every small team is—the fix isn't more meetings or better documentation discipline. It's automation.

Start small. Pick one annoying question. Build something that answers it. Then build the next one.

Three months in, we're not spending Saturdays hunting through old Slack threads. We're building software. Which is what we're actually paid to do.

Building something similar and want to chat about the details? We're happy to share what worked (and what didn't). Get in touch