Walk into any startup today and you'll find a familiar scene. Every laptop has Claude or ChatGPT open. Every team member has a personal prompt library and a few go-to workflows.

Yet when founders look honestly at the impact, the gains feel modest. Some efficiency here, some quality improvement there. Nothing that bends the curve for the whole company.

Adarsh Tadimari, co-founder of Plotline, has a diagnosis for this: AI tools aren't the problem, the architecture around them is.

In a tech exchange workshop, Adarsh walked founders and operators through the AI intelligence layer his team built at Plotline. This is an organizational brain that operates autonomously across every function in his 25-person company. It handles 85% of Plotline’s complex support tickets, filling enterprise RFPs in <5 minutes, iterating on their landing pages without a web developer in the loop, and a lot more.

This guide is a deep-dive into how this intelligence layer came to life at Plotline, how it works, and how you can build one for your team.

Breaking Down The Intelligence Layer (Why Your Current AI Setup Is Hitting a Ceiling)

Every Tuesday morning, a customer success manager in your team is preparing for a quarterly business review. They open ChatGPT and type out a prompt. First, a paragraph about what your company does. Then the last six weeks of thread with the customer. Then the support ticket history. Then the commercial context. Then the call notes.

Only after all of that do they finally ask the model to draft the email.

20 minutes later, a salesperson two desks away repeats these steps. And a few hours later, a product manager does it again. If you multiply this across a 25-person company, the trade-off becomes clear as day.

Every person, every day, re-explains the same context to AI tools and goes through the hassle of copy-pasting the input/output. Three problems are at play here:

1. Redundant context: Everyone is re-explaining the same context to AI from scratch, every single time. There’s no shared context layer that works across your entire team. Every employee has to share it from scratch every single time.
2. Siloed outputs: Every good workflow stays locked inside one chat history. When a sales rep finds a good prompt, it doesn’t go to the CS manager or the product team. At Plotline, this was the invisible cost: critical knowledge stays siloed within teams and the conversation box.
3. No layered learning: When every session starts from a blank slate, there's no learning and the model never gets smarter. Tomorrow's query starts from the same blank slate as today's. So your team ends up doing the same manual investigation, writing the same context, finding the same answers week after week.

These problems create a real ceiling. A team organised this way might get 50-100% productivity improvement from AI. But the daily time-sink can almost nullify these gains because your workflows aren’t optimized for speed.

The key problem: The architecture problem is invisible to most teams because the productivity gains feel good enough.

What an AI Intelligence Layer Actually Is

The big shift for Plotline was moving AI from personal assistant to company-wide operating layer.

This intelligent operating layer has three components, each of which directly tackles the challenges we outlined above.

• Company context: The agent already knows everything about the company, its product, systems, customers, and workflows. Nobody needs to repeatedly paste essential context into a prompt. It’s already available.
• Tool access: The system has read and write access to every system of record in tools like HubSpot, Linear, Pylon, the codebase, the database, Slack, Grafana. The agent can directly act on the task it’s assigned.
• Self-learning mechanism: The system gets sharper and smarter over time. Feedback from one team member improves the output for everyone. The institutional knowledge works to the team’s advantage.

Adrash explains the best mental model to embrace this shift: instead of thinking of the agent as a chatbot, think of it as a new team member who has read every internal doc, has access to every tool, and never forgets anything.

What This Organizational Brain Looks Like in Practice

Before getting into how to build this operating layer, it’s worth understanding the full surface area this can cover. Here are a few production use cases from the Plotline team.

1. Customer Support

Plotline’s CS team was fielding about 20 tickets a day, each taking roughly an hour to resolve. A typical thread ran 16-20 replies, involving dashboard checks, database lookups, configuration audits, and a lot of back-and-forth with the customer.

The support team was drowning, and the engineering team kept getting pulled in.

That’s when Adarsh decided to test how AI could help. He gave the AI tool access to the support system of record, a read-only connection to the database, the codebase, and a small library of skill files describing how support issues at Plotline actually get debugged.

Within a few days, as results came in and trust built, the team enabled auto-reply. And by the end of the first two weeks, 85% of complex tickets were being resolved automatically, often in minutes. The support team went from drowning to steering.

2. Sales

Enterprise RFPs are a tax on the best engineers in a company. The team has to spend a day or two filling out security questionnaires and product matrices that they’ve likely answered five times before.

A recent RFP at Plotline was 21 pages with product questions, security posture, and integration details. The agent completed it in five minutes by pulling from internal docs, the codebase, and the Linear roadmap. The solution architect opened the completed draft, read it, made a few minor edits, and hit send.

The total time from request to delivery: 30 minutes. The old way cost 1–2 days of senior engineering time.

Now, the agent has become the first-line technical advisor for the sales team. When a prospect asks whether Plotline supports a specific integration or edge case, the sales rep directly asks the agent instead of looping in engineering.

3. Marketing

One of Plotline's marketers wanted to improve the company's landing pages.

The old workflow would have meant filing a Figma ticket, booking a web developer, and waiting two weeks. Instead she opened Slack, described what she wanted to the agent, reviewed the preview link the agent created. Over a few days, she shipped a materially improved version of the site without any developer or designer.

Thanks to automated workflows, the marketing team’s time now goes to strategy and creative direction instead of content production.

For example, key takeaways and learnings from sales calls automatically feed into iterations for Google and LinkedIn ad copy. Plus, release notes from the engineering team are converted to blog posts.

4. Customer Success

Every morning, the agent reviews every campaign each customer created in the last week, scans call notes for open items, and shows one prioritised action item per customer. The team gets a detailed action plan for the day.

What’s even more impactful is the workflow around feature requests.

When a customer raises a custom use case that’s not a product feature, the agent creates a workaround for achieving around 90% of the desired outcome. The CS manager sends the workaround to unblock the customer. This keeps unnecessary feature requests off the engineering backlog, and lets the team focus on what actually moves the needle.

5. Product

When a feature request comes in, the agent:

• Checks whether an existing workaround solves the problem
• Searches Linear for an existing ticket
• Creates a new one only if needed

A weekly intelligence report produced by the agent sets up the product team for a productive week with complete alignment. It covers every customer call, support ticket, and feature request from the previous week, organised into three buckets: (a) what customers want that you don't have, (b) where they're struggling, (c) what's working.

6. Engineering

Engineers at Plotline now create PRs for small changes directly from a Slack message. The agent clones the monorepo, makes the change, pushes a branch, and returns a preview link. The entire cycle happens inside the same Slack thread where the bug was first raised.

Every PR runs through a review bot that carries full company context. It does a first pass before a human engineer merges. What’s even better is that the review bot itself improves every week, learning from the comments human reviewers leave on its earlier reviews.

Grafana alerts flow into a Slack channel where the agent triages each incident, identifies the likely cause by reading logs and checking recent deployments, and tags the right engineer. Nobody has to wade through dashboards at 2 am to find out what broke.

How to Build This AI-Powered Organizational Brain for Your Company

Adarsh built this intelligence layer over 7-8 weeks, spending a couple of days every week. In his own words:

“I was actually the skeptic. My co-founder was the one pushing me. I kept saying, 'this is too complex, AI cannot do this, what if it responds wrongly to a customer?' Looking back, the thing I would do differently is trust the models sooner.”

If, like Adarsh, you’re eager to move from skepticism to implementation, here's the blueprint for building your own AI-powered organizational brain. We break down what to do before you write a single line of agent code, and what to do once you start.

Prerequisites

The most important prerequisite is building an automation-first mindset. Every recurring task in your function can be automated. Instead of thinking “let me just quickly do it this time, and automate it later,” you want to build the automation right away.

Adarsh puts it this way:

“Every time we get a task, if it is something that is going to happen again, we ask: how can I do this so that I don't have to do it again? That mindset shift is what leads you to building a really good agent system internally.”

Another essential piece of the puzzle is tooling. Some tools are agent-friendly, but many are not. The general rule is simple: choose systems of record with strong API and MCP support. And if your current systems don’t support this, migrate to other solutions that do. Here’s how Plotline approached this:

• Website: Migrated from Webflow to Astro because Webflow's MCP server was too slow and limiting for the kind of changes the agent needed to make.
• Documentation: Migrated from Notion and Google Docs to GitBook. GitBook’s git-based interface makes it easy for the agent to raise a PR with a diff instead of editing a doc in place.
• Design: Migrated from Figma to Penpot, for the same reason.

The third prerequisite is code consolidation.

Plotline had seven repositories: dashboard, backend, LLM servers, and SDKs for Android, iOS, React Native, and Flutter. A single feature required up to seven PRs, each needing separate review, testing, and merging. They moved to a monorepo.

For the humans reviewing agent output, the change meant they could test every PR with one preview link in Slack and merge it in minutes, instead of cloning seven repos to a laptop to verify behaviour.

Building the Technical Stack

Here’s the tech stack running at Plotline today:

• Base layer: The Claude Code SDK. A CLI-based agent, not raw API calls. The CLI capability is essential, because it lets the agent read files, write code, and run commands, not just generate text. This is the difference between an assistant that talks about your system and an agent that operates on it.
• Tool connections: MCP servers or direct API integrations to every relevant system, including HubSpot, Apollo, Linear, Pylon, GitHub, Grafana, and Slack.
• Database: MongoDB Atlas. Chosen for flexibility in document structure and native vector search via Voyage embeddings, which powers retrieval for the memory layer.
• Infrastructure: An EC2 instance, with the agent operating like a developer on that machine. It clones repositories into /tmp, makes changes, pushes to new branches, and returns preview links.
• Interface layer: Slack, Linear, and Pylon. Team members call the agent from wherever they already work, instead of learning a new tool.

The Build Process From Prototype to Production

This is the step-by-step Adarsh recommends for any team starting out. It’s designed to help you pick one workflow or problem statement, make it work, then expand.

Step 0: Pick one use case

Choose the most painful, most repetitive workflow in one team. For Plotline, that was support. You can work with use cases like RFPs, onboarding QBRs, or code review.

The goal is to start where the pain is sharpest, because that’s where you can see impact that translates into other functions.

Step 1: Collect five real examples

Find five past instances of this task being completed manually. These become your evaluation set. You’ll use them to test whether the agent is doing the job well enough to deploy.

Step 2: Set up the CLI agent

Install the Claude Code SDK. Connect it to the tools this specific use case needs. Don’t connect everything in the first go.

Step 3: Write the first skill file

A skill file is a markdown file that gives the agent step-by-step judgment for a specific use case.

Don’t write it manually. Ask Claude to generate it by analysing how the task has historically been done. Feed it past tickets, past emails, past PRs. Let the model do the pattern extraction and edit what it produces.

Step 4: Test against your five examples

Validate that the agent handles these cases correctly before you let it anywhere near real users. If it fails, refine the skill file and try again.

Step 5: Add the self-review cron

Once the basic flow works, add a daily job. The job asks the agent to review everything it did in the last 24 hours for this use case, identify its own errors, and raise a PR to update its own skill file. This is the learning loop. Without it, your skills decay. With it, they compound.

Step 6: Deploy behind a VPN

Roll it out to the first team, monitor for a few days, then expand.

That is the full weekend-to-production loop. Simpler than it sounds. The hardest part is picking the first use case and committing to it.

Memory Architecture Behind This Brain

Memory can be the kryptonite for even the best AI systems. Plotline's architecture accounts for this and functions with three layers of memory:

• Short-term memory: Per-conversation context. Handled natively by Claude's chat.
• Semantic memory: RAG-based retrieval. When a query comes in, semantically relevant memory items are pulled and fed into context. The model decides what is useful.
• Skill files: The long-term structured knowledge layer. Step-by-step instructions, debugging flows, judgment rules. Skills always take priority over memory when there is a conflict.

Once a week, the system runs a memory consolidation process. It reviews short-term memory, identifies conflicts, and raises PRs to update skill files. The system forgets what it should forget and remembers what matters.

Using Skill Files for Self-Improvement

Skills are a cache for your company's institutional knowledge.

Most companies lose institutional knowledge every time someone leaves, every time a Slack thread scrolls out of memory, every time a decision is made in a meeting and never written down.

Skill files become your infrastructure against that default. They enable the AI agent to learn and improve independently. The system only gets sharper over time without manual effort.

Skills create a self-learning workflow in three ways:

• Explicit feedback: A team member tells the agent "you are handling X wrong." The agent corrects its current answer, then raises a PR to update the skill file so the fix persists for everyone.
• Passive learning: The daily cron reviews all conversations, PR comments, customer replies, and call transcripts. Any new information that contradicts or extends a skill triggers a PR.
• Product changes: When a new feature merges, the agent detects it during its daily review and updates the relevant skill file to reflect the new behaviour.

For example, Plotline's campaign visibility skill is a nine-step debugging flow. In a recent update, the team added a new campaign status called "scheduled" that a product engineer had shipped the week before. The agent noticed the new status in the codebase, realised its existing skill file did not cover it, and raised a PR to update itself.

Over to You: Build Your Organizational Brain Today

Almost every company has a knowledge problem.

The best way to handle a difficult customer lives in one person's head. The most effective sales narrative is locked in one person's drive folders. The critical debugging flow exists in a Slack thread nobody will find again.

Besides, knowledge leaks almost too easily when your top employees leave, institutional memory fades, and processes are forgotten or reinvented.

What Plotline built is, at its core, a solution to this all-too-common problem.

This is an intelligence layer that captures how work gets done and makes it available to everyone. AI is the mechanism running the show, but the real asset is the knowledge architecture underneath it. Build yours now with this playbook.