Build your company brain

Company Brain/
├── security/
│   ├── _staging/        # new or updated files awaiting review
│   └── approved/        # trusted, published knowledge
├── legal/
│   ├── _staging/
│   └── approved/
├── product/
│   ├── _staging/
│   └── approved/
├── operating-rules/     # rules that govern how agents behave
│   └── agent-operating-rules.md
└── outputs/             # content generated by agents, saved back

mkdir company-brain && cd company-brain

python3 -m venv .venv
source .venv/bin/activate

pip install box-sdk-gen python-dotenv

BOX_CLIENT_ID=your_client_id
BOX_CLIENT_SECRET=your_client_secret
BOX_ENTERPRISE_ID=your_enterprise_id
BOX_METADATA_TEMPLATE_KEY=your_template_key
STAGING_FOLDER_ID=your_domain_staging_folder_id
APPROVED_FOLDER_ID=your_domain_approved_folder_id

import os
from dotenv import load_dotenv
from box_sdk_gen import BoxClient, BoxCCGAuth, CCGConfig

load_dotenv()

def get_box_client() -> BoxClient:
    config = CCGConfig(
        client_id=os.getenv("BOX_CLIENT_ID"),
        client_secret=os.getenv("BOX_CLIENT_SECRET"),
        enterprise_id=os.getenv("BOX_ENTERPRISE_ID"),
    )
    auth = BoxCCGAuth(config=config)
    return BoxClient(auth=auth)

from box_sdk_gen import (
    AiItemBase,
    CreateAiExtractStructuredFields,
    CreateAiExtractStructuredFieldsOptionsField,
)
from box_client import get_box_client

REVIEW_FIELDS = [
    CreateAiExtractStructuredFields(
        key="summary",
        display_name="Summary",
        type="string",
        prompt="A two to three sentence summary of what this document contains.",
    ),
    CreateAiExtractStructuredFields(
        key="suggested_domain",
        display_name="Suggested domain",
        type="enum",
        prompt="The single domain this content best belongs to.",
        options=[
            CreateAiExtractStructuredFieldsOptionsField(key="security"),
            CreateAiExtractStructuredFieldsOptionsField(key="legal"),
            CreateAiExtractStructuredFieldsOptionsField(key="product"),
            CreateAiExtractStructuredFieldsOptionsField(key="other"),
        ],
    ),
    CreateAiExtractStructuredFields(
        key="suggested_tags",
        display_name="Suggested tags",
        type="string",
        prompt="Three to six comma-separated topic tags for retrieval.",
    ),
    CreateAiExtractStructuredFields(
        key="content_health_score",
        display_name="Content health score",
        type="float",
        prompt=(
            "A score from 0 to 100 for how usable this is as trusted knowledge. "
            "Lower the score for stale dates, missing ownership, unclear status, "
            "or content that reads like an unreviewed draft."
        ),
    ),
    CreateAiExtractStructuredFields(
        key="review_notes",
        display_name="Review notes",
        type="string",
        prompt=(
            "Concise notes on any issues an owner should resolve before approval, "
            "such as missing owner, stale dates, duplicate guidance, or draft assumptions."
        ),
    ),
]

def review_file(file_id: str) -> dict:
    client = get_box_client()

    response = client.ai.create_ai_extract_structured(
        items=[AiItemBase(id=file_id)],
        fields=REVIEW_FIELDS,
    )

    return response.to_dict()["answer"]

import os
from dotenv import load_dotenv
from box_sdk_gen import BoxClient, CreateFileMetadataByIdScope

from box_client import get_box_client
from review import review_file

load_dotenv()

def build_governance(review: dict) -> dict:
    return {
        "domain": review.get("suggested_domain", "other"),
        "owner": "unassigned",
        "status": "staged",
        "contentHealthScore": review.get("content_health_score", 0),
        "summary": review.get("summary", ""),
        "tags": review.get("suggested_tags", ""),
        "reviewNotes": review.get("review_notes", ""),
    }

def apply_governance(client: BoxClient, file_id: str, governance: dict):
    template_key = os.getenv("BOX_METADATA_TEMPLATE_KEY")
    client.file_metadata.create_file_metadata_by_id(
        file_id=file_id,
        scope=CreateFileMetadataByIdScope.ENTERPRISE,
        template_key=template_key,
        request_body=governance,
    )

def process_staging_folder(client: BoxClient, folder_id: str):
    items = client.folders.get_folder_items(folder_id).entries

    for item in items:
        if item.type != "file":
            continue

        print(f"\nReviewing: {item.name} ({item.id})")
        review = review_file(item.id)
        governance = build_governance(review)

        print(f"  Domain:  {governance['domain']}")
        print(f"  Health:  {governance['contentHealthScore']}")
        print(f"  Summary: {governance['summary']}")
        if governance["reviewNotes"]:
            print(f"  Notes:   {governance['reviewNotes']}")

        apply_governance(client, item.id, governance)
        print("  Governance metadata applied.")

def main():
    client = get_box_client()
    staging_folder_id = os.getenv("STAGING_FOLDER_ID")
    process_staging_folder(client, staging_folder_id)

if __name__ == "__main__":
    main()

python3 intake.py

import os
from dotenv import load_dotenv
from box_sdk_gen import (
    BoxClient,
    UpdateFileMetadataByIdScope,
    UpdateFileMetadataByIdRequestBody,
    UpdateFileMetadataByIdRequestBodyOpField,
    UpdateFileByIdParent,
    FolderReferenceV2025R0,
    HubItemOperationV2025R0,
    HubItemOperationV2025R0ActionField,
)

from box_client import get_box_client

load_dotenv()

def approve_file(client: BoxClient, file_id: str, owner: str):
    template_key = os.getenv("BOX_METADATA_TEMPLATE_KEY")
    client.file_metadata.update_file_metadata_by_id(
        file_id=file_id,
        scope=UpdateFileMetadataByIdScope.ENTERPRISE,
        template_key=template_key,
        request_body=[
            UpdateFileMetadataByIdRequestBody(
                op=UpdateFileMetadataByIdRequestBodyOpField.REPLACE,
                path="/status",
                value="approved",
            ),
            UpdateFileMetadataByIdRequestBody(
                op=UpdateFileMetadataByIdRequestBodyOpField.REPLACE,
                path="/owner",
                value=owner,
            ),
        ],
    )
    print(f"Approved file {file_id}, owner set to {owner}")

def move_to_approved(client: BoxClient, file_id: str, approved_folder_id: str):
    client.files.update_file_by_id(
        file_id, parent=UpdateFileByIdParent(id=approved_folder_id)
    )
    print(f"Moved file {file_id} to approved folder {approved_folder_id}")

def create_domain_hub(client: BoxClient, domain: str) -> str:
    hub = client.hubs.create_hub_v2025_r0(
        f"{domain.title()} Knowledge Base",
        description=(
            f"Curated, approved {domain} knowledge for the company brain. "
            "Answers are grounded in reviewed, source-backed content."
        ),
    )
    print(f"Created hub: {hub.title} (ID: {hub.id})")
    return hub.id

def add_folder_to_hub(client: BoxClient, hub_id: str, folder_id: str):
    client.hub_items.manage_hub_items_v2025_r0(
        hub_id,
        operations=[
            HubItemOperationV2025R0(
                action=HubItemOperationV2025R0ActionField.ADD,
                item=FolderReferenceV2025R0(id=folder_id),
            )
        ],
    )
    print(f"Added approved folder {folder_id} to hub {hub_id}")

def main():
    client = get_box_client()

    approved_folder_id = os.getenv("APPROVED_FOLDER_ID")

    # Replace with a file ID from your staging folder and the accountable owner.
    file_id = "YOUR_FILE_ID"
    owner = "security-team@example.com"
    domain = "security"

    approve_file(client, file_id, owner)
    move_to_approved(client, file_id, approved_folder_id)

    hub_id = create_domain_hub(client, domain)
    add_folder_to_hub(client, hub_id, approved_folder_id)

    print(f"\n{domain.title()} knowledge base ready. Hub ID: {hub_id}")

if __name__ == "__main__":
    main()

python3 publish.py

from dotenv import load_dotenv
from box_sdk_gen import BoxClient, CreateAiAskMode, AiItemAsk

from box_client import get_box_client

load_dotenv()

def ask_company_brain(client: BoxClient, hub_id: str, question: str):
    response = client.ai.create_ai_ask(
        mode=CreateAiAskMode.SINGLE_ITEM_QA,
        prompt=question,
        items=[AiItemAsk(type="hubs", id=hub_id)],
        include_citations=True,
    )
    return response

def main():
    client = get_box_client()

    hub_id = "YOUR_HUB_ID"  # From Step 7

    questions = [
        "What is our approved policy for handling customer data at rest?",
        "Which security controls must a new integration pass before launch?",
    ]

    for question in questions:
        print(f"\nQ: {question}")
        response = ask_company_brain(client, hub_id, question)
        print(f"A: {response.answer}")

        if response.citations:
            print("Sources:")
            for citation in response.citations:
                print(f"  - {citation.name}")

if __name__ == "__main__":
    main()

python3 ask.py

company-brain/
├── .env
├── .venv/
├── ask.py
├── box_client.py
├── intake.py
├── publish.py
└── review.py

- Always authenticate as the Box service account, never a personal user.
- Only operate inside the approved folders and Hubs you are given.
- Answer only from approved content, and cite the source files.
- Ask before deleting or overwriting content; preserve version history.
- Save generated outputs back to the outputs folder for reuse.

import os
from box_sdk_gen import BoxClient

def find_low_health_content(client: BoxClient, template_key: str, threshold: int = 60):
    enterprise_id = os.getenv("BOX_ENTERPRISE_ID")
    results = client.search.search_by_metadata_query(
        from_=f"enterprise_{enterprise_id}.{template_key}",
        ancestor_folder_id="0",  # search the whole enterprise; scope to the brain folder in production
        query="status = :status AND contentHealthScore < :score",
        query_params={"status": "approved", "score": threshold},
    )
    for entry in results.entries:
        print(f"Needs review: {entry.name} ({entry.id})")