Custom GPT Messenger Chrome Extension
A custom GPT generates structured Hero Stories through a Messenger Chrome extension with token login, a GPT-builder web app, and verified team key isolation.
- custom GPT Messenger Chrome extension
- custom GPT Chrome extension
- GPT content production system
- custom GPT web application
- AI client narrative generation
- GPT builder web application
Overview
The project at a glance
A growing digital marketing agency needed a way to scale the production of branded client narratives across their delivery teams. Their team members were producing story-driven marketing content for clients, but the process relied on individual prompting habits and inconsistent formatting, making output difficult to review, standardize, and hand between team members.
Octacer designed and delivered a complete content production system: a custom GPT configured to generate structured narrative documents, a Chrome extension that connects the agency's workers directly to the GPT through a Messenger-style interface, and a web application that allows the agency to build and manage multiple GPT configurations. The system includes token-based authentication, per-team key isolation, and an approval workflow that ensures only verified team members can submit content requests.
The initiative combined product engineering with a custom browser extension, a GPT-builder web application, and an AI-driven document generation layer — all oriented around one objective: making high-quality, consistent client narratives repeatable across the team.
What the engagement had to achieve
- Enable team members to generate structured client narratives through a simple, familiar interface
- Standardize GPT output so content is consistent across users
- Control access so only verified team members can use the system
- Allow the agency to build and configure multiple GPTs without engineering involvement
The story
From inconsistent prompts
What was at risk
The Challenge
The agency's team members were generating client narratives manually, with each person composing their own prompts and passing the results through personal tools. That created two recurring problems: output varied widely in structure and quality depending on who generated it, and the agency had no clean way to govern who could access the GPT, which GPT they were using, or what was being produced.
Each team member prompted the GPT with their own phrasing, examples, and instructions. The result was a body of client content with no uniform structure, inconsistent tone, and variable quality. Reviewers had to rework a large share of the output before it could be delivered to clients. The agency needed the GPT to produce a consistent, branded structure regardless of who initiated the request.
The GPT was accessible to anyone with the link. There was no mechanism to verify that a person requesting content was a current team member, and no way to restrict which GPT configurations different teams could use. As the agency planned to build multiple GPTs for different service lines, they needed a way to isolate access by team and key so that a person logged in from one team could not generate content using another team's GPT configuration.
There was no defined delivery path between the GPT and the final formatted document. Team members generated content in a generic chat interface, then copied the output into their own document templates — reintroducing manual steps and formatting drift. The agency wanted the narrative to arrive already structured for direct use, with the generation flow operating like an internal production tool rather than an open chat.
How we responded
The Solution
Octacer's approach was to turn the GPT from a general-purpose chat into a governed production system. Instead of asking team members to compose prompts in a standalone chat window, Octacer built a Chrome extension that sits inside the team's day-to-day tool, opens a conversational interface next to their work, and submits structured requests to a custom-built GPT. The design solved the three failure modes at once: consistent output, because the prompting logic was embedded in the system rather than left to individual users; controlled access, because every request passed through token authentication and per-team key isolation; and repeatable delivery, because the output arrived as a structured document ready for review and handoff.
The key decision was to stop relying on team members to compose effective prompts. Octacer embedded the prompt construction inside the Chrome extension and the web application, so the GPT always received a well-formed instruction with the correct structure, tone, and output format — regardless of which team member initiated the request. This removed the primary source of output inconsistency.
“Prompting is product logic, not user responsibility.”
Because the GPT would be used by multiple teams across the agency, access control had to be granular. Octacer implemented token-based login tied to the team's workspace, with each authenticated session bound to the user's identity and team membership. The GPT only accepted requests carrying a valid token, which made it possible to revoke access, audit usage, and enforce team boundaries.
“Every request must be traceable to a verified team member.”
The agency planned to build multiple GPTs, one per service line or team. Octacer designed the system so each GPT configuration is bound to a team key, and a user's authenticated session only exposes the GPTs their team key permits. This creates a hard boundary: a user authenticated under one team cannot see or trigger another team's GPT, even if they obtain its direct link.
“A team key shapes what a user can see and generate.”
Octacer built a web application where the agency can define new GPT configurations — name, description, system prompt, output structure, and team binding — without engineering involvement. This means the agency can extend the system to new service lines on its own, while the Chrome extension, authentication layer, and key isolation remain unchanged.
“The agency owns the GPTs; the platform owns the plumbing.”
Deliverables
What we built
The concrete capabilities designed, built, and shipped in this engagement.
Messenger-style Chrome extension
The team member's primary interface. The extension embeds a conversational panel directly in the browser, modeled after a Messenger experience so adoption required no training. A team member opens the panel, types what kind of narrative they need, and the extension constructs a structured request — including the user's identity token and team context — and submits it to the configured GPT.
- Conversational interaction alongside the user's existing browser workflow
- Structured request construction that removes prompt-composition skill from the user
- Token-based session attached to every submission
Custom GPT for structured narrative generation
The generation engine behind the system. A custom GPT configured to produce structured Hero Stories — branded narrative documents with a fixed internal format. The GPT receives the user's request plus the agency's formatting rules and returns a structured document that is ready for review rather than raw conversational text.
- Produces consistent narrative structure across every request
- Output arrives in a document-ready format
- Prompting logic is owned by the system, not the individual user
GPT-builder web application
The administrative layer that lets the agency define and manage GPT configurations. An administrator can create a new GPT, set its system prompt and output structure, assign it to a team, and publish it — all through a browser interface.
- Self-serve GPT creation without code changes
- Configurable output structure per GPT
- Team binding applied at configuration time
Token login and team key isolation
The access-control layer. Every user authenticates through a token login that binds their session to their identity. Each GPT configuration carries a team key, and the system only surfaces GPTs a user's team is permitted to use. Requests that fail authentication or fall outside the user's team scope are rejected before reaching the GPT.
- Verified identity required for every generation request
- Hard isolation between team GPT configurations
- Revocable access through token management
Structured output delivery
Instead of returning plain conversational text, the GPT produces structured Hero Story documents that follow the agency's required format. The output is available immediately for review and handoff, removing the copy-and-reformat step that previously introduced inconsistency.
- Structured output aligned with the agency's narrative format
- Reduced manual reformatting between generation and delivery
- Reviewable documents rather than raw chat transcripts
Technology
The stack
The tools behind the build, and the role each one played.
Core platform
OpenAI Custom GPT
the generation engine producing structured Hero Story narratives from configured system prompts.
Chrome Extension API
delivered the Messenger-style interface inside the team's browser workflow.
Backend & authentication
Node.js
served the GPT-builder web application and API endpoints.
Token-based authentication
verified user identity on every request before submission to the GPT.
Web application
React
powered the GPT-builder interface for creating and managing configurations.
Outcome
What changed
The delivered system changed how the agency's team members produce client narratives. Instead of composing individual prompts in an open chat, they now generate structured documents from inside their browser, with access controlled by verified identity and team boundaries.
Output consistency
standardizednarrative structure is now determined by the system's configured prompt, not by individual prompting habits.
Access control
enforcedevery request is authenticated, and GPT configurations are isolated by team key.
Prompt engineering responsibility
transferredremoved from the user and embedded in the platform, removing the main source of output variability.
GPT administration
self-servethe agency can create and configure new GPTs without engineering involvement.
Beyond the launch
Lasting improvements
The changes that keep paying off after the engagement ended.
- Reduced the manual steps between generation and final formatted output
- Gave the agency an audit trail of who generated what and when
- Established a reusable production framework the agency can extend to additional GPTs and teams
Related work
Legal Intake Automation for a Criminal-Defense Law Firm
Converts scanned packets into reviewed structured data and syncs it into the firm's case-management system without manual retyping.
View case studyAI Upload Validation for an Agri-Tourism Grant Portal
Real-time AI verification flags invalid documents and farm photos during upload while a fail-open policy keeps legitimate applicants unblocked.
View case studyAirtable Review-Form Contact and Retailer Automation
Links review submissions to the right Contact and Retailer by email and creates a flagged Contact when no match exists without dropping submissions.
View case studyReady to build something like this?
Let's discuss how we can deliver a similar outcome for your team — scoped to your stack, your data, and your workflow.