Unlock Team Efficiency with a Custom AI Agent

Answering the same internal questions again and again? From “Where’s the campaign tracker?” to “How do I format this deck?”, knowledge gets stuck in silos. AI agents can fix that. With a simple setup, you can build a smart assistant that gives teams instant access to the answers they need.

Imagine being able to ask about campaign history, tool instructions, or brand guidelines and get fast, accurate answers without searching through files or messaging coworkers. With just a few lines of code, you can build an internal agent that does exactly that.

What This Agent Can Do

• Content and Brand Guidelines – Make tone, formatting, language, and visuals easy to find and follow
• Campaign History – Keep a record of what’s been done, what worked, and what didn’t
• Tool and Workflow How-Tos – Help users understand internal tools, forms, and processes
• Company-wide Changes – Support transitions with clear, centralized answers

These agents reduce repetitive questions, improve onboarding, and unlock knowledge that would otherwise stay buried.

So how do you actually create one of these agents? It doesn’t take much. In fact, with just a few core pieces—a text file, an API key, and a small Python script—you can have a working internal agent ready to answer questions. Below I’ll show you how to put it together.

The Simplest Working Version

Here’s a step-by-step breakdown of how to build a basic internal agent using the OpenAI SDK, a simple text file, and FastAPI to handle interactions. This approach can be adapted to use other models or frameworks as needed.

from fastapi import FastAPI

app = FastAPI()

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

OPENAI_API_KEY=your_api_key_here

with open("knowledge.txt", "r") as f:
    context = f.read()

system_prompt = (
    "Use the following document to answer the user's question:\
"
    f"{context}"
)

from openai import OpenAI
openai = OpenAI()

from pydantic import BaseModel

class ChatRequest(BaseModel):
    question: str
    history: list[str] = []

@app.post("/chat")
def chat(request: ChatRequest):
    messages = [
        {"role": "system", "content": system_prompt},
        *[{"role": "user", "content": m} for m in request.history],
        {"role": "user", "content": request.question},
    ]

    response = openai.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

    return {"answer": response.choices[0].message.content}

Running the Agent

To run this agent locally, create a virtual environment in your terminal and install the required libraries: FastAPI, Uvicorn, python-dotenv, OpenAI, and Pydantic. Include your API key in a .env file and your internal content in a knowledge.txt file.

Then launch the app using a command like:

uvicorn main:app --reload

Once it's running, you can interact with the agent through a script, curl command, or by connecting it to a simple frontend.

Put Your Knowledge to Work

An internal agent isn't just about saving time—it can change how teams interact with information. Instead of repeating answers, rewriting onboarding emails, or searching through outdated slides, people can ask questions like “What’s the latest version of our sales pitch?”, “Where are the design specs from the Q2 launch?”, or “How should I write this in our tone of voice?” and get clear, instant answers.

This guide outlined one way to get started, but it’s not the only way. You can swap in a different model, adjust the behavior, or expand your content. The core idea is simple: structure your knowledge in a way that makes it usable, accessible, and smart.

Once that’s in place, the rest becomes easier to build. Start small. Improve over time. You don’t need a massive system to make a real difference.