Create a Custom GPT‑5 AI Agent to Automate Your Daily Workflow

#Why Build Your Own GPT‑5 Agent Now?

OpenAI released GPT‑5 this month, delivering faster inference, better context handling, and built‑in function calling. Those upgrades make it practical to run a personal AI assistant that can understand nuanced requests, remember short‑term preferences, and interact directly with the tools you already use. For knowledge workers, the payoff is immediate: fewer clicks, fewer manual drafts, and more mental bandwidth for creative work.

#Prerequisites

#OpenAI Account and API Access

You need an active OpenAI account with access to the GPT‑5 endpoint. Sign up at platform.openai.com and generate an API key. Keep the key secret; treat it like a password.

#Basic Programming Knowledge (Python)

The guide uses Python because the official OpenAI client library is most mature there. Familiarity with virtual environments, pip, and JSON is enough to follow each step.

#Productivity Tools to Target

We’ll demonstrate integration with three widely used services:

• Gmail for email automation
• Google Calendar for scheduling
• Todoist for task management

#Setting Up the Development Environment

1. Install Python 3.11 or newer.
2. Create a virtual environment: python -m venv gpt5-agent
3. Activate it (source gpt5-agent/bin/activate on macOS/Linux or gpt5-agent\Scripts\activate on Windows).
4. Install required packages: pip install openai google-api-python-client google-auth-httplib2 google-auth-oauthlib todoist-api-python
5. Store your OpenAI key in an environment variable named OPENAI_API_KEY for security.

#Designing Your Agent’s Personality and Scope

Before writing code, decide what the assistant should do and how it should sound. A clear prompt template guides GPT‑5’s responses and prevents drift.

• Role: "You are a concise, friendly productivity assistant."
• Capabilities: Summarize emails, draft replies, suggest meeting times, create tasks.
• Boundaries: Never share personal data without explicit confirmation.

Save this template in a variable called system_prompt – the model will treat it as a constant instruction.

#Coding the Core Agent with the GPT‑5 API

The following snippet creates a helper function that sends a user request to GPT‑5 and returns the model’s JSON‑structured answer.

import os, json, openai
openai.api_key = os.getenv("OPENAI_API_KEY")
SYSTEM_PROMPT = """You are a concise, friendly productivity assistant. Respond only with a JSON object containing the fields 'action' and 'payload'. Do not add explanations."""
def call_gpt5(user_message: str) -> dict:
response = openai.ChatCompletion.create(
model="gpt-5",
messages=[{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_message}],
temperature=0.2,
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)

This function guarantees a predictable JSON output, which our integration layer can parse without fragile string handling.

#Connecting to Email – Gmail Example

We’ll use Google’s OAuth 2.0 flow to obtain a token that lets the agent read and send messages. The code below fetches the latest unread email, asks GPT‑5 to draft a reply, and then sends it.

from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
SCOPES = ["https://www.googleapis.com/auth/gmail.modify"]
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
service = build('gmail', 'v1', credentials=creds)
def get_unread_email():
results = service.users().messages().list(userId='me', q='is:unread', maxResults=1).execute()
msg_id = results['messages'][0]['id']
msg = service.users().messages().get(userId='me', id=msg_id, format='full').execute()
return msg
def send_reply(thread_id, reply_text):
message = {
'raw': base64.urlsafe_b64encode(reply_text.encode()).decode()
}
service.users().messages().send(userId='me', body=message).execute()
email = get_unread_email()
subject = next(h['value'] for h in email['payload']['headers'] if h['name']=='Subject')
body_snippet = email['snippet']
prompt = f"Draft a short, polite reply to this email. Subject: {subject}. Body: {body_snippet}."
result = call_gpt5(prompt)
if result['action'] == 'reply':
send_reply(email['threadId'], result['payload']['text'])

Notice how the model’s JSON output tells us the required action (reply) and the exact text to send. This pattern repeats for other tools.

#Syncing with Calendar – Google Calendar Example

Scheduling is a natural fit for an AI assistant. The agent can propose time slots based on existing events and then create a meeting.

from googleapiclient.discovery import build
from datetime import datetime, timedelta
calendar_service = build('calendar', 'v3', credentials=creds)
def list_free_slots(days=2, slot_length=30):
now = datetime.utcnow().isoformat() + 'Z'
end = (datetime.utcnow() + timedelta(days=days)).isoformat() + 'Z'
events = calendar_service.events().list(calendarId='primary', timeMin=now, timeMax=end, singleEvents=True, orderBy='start').execute()
# Simplified free‑slot calculation omitted for brevity
return ["2026-10-10T10:00:00Z", "2026-10-10T14:30:00Z"]
free = list_free_slots()
prompt = f"User wants a 30‑minute meeting with Alex next week. Propose the earliest free slot from this list: {free}. Return JSON with 'action':'schedule' and 'payload' containing 'start' and 'end' timestamps."
result = call_gpt5(prompt)
if result['action'] == 'schedule':
event = {
'summary': 'Meeting with Alex',
'start': {'dateTime': result['payload']['start'], 'timeZone': 'UTC'},
'end': {'dateTime': result['payload']['end'], 'timeZone': 'UTC'}
}
calendar_service.events().insert(calendarId='primary', body=event).execute()

The assistant’s suggestion is turned into a concrete calendar event with a single API call.

#Managing Tasks with Todoist – Example

Todoist’s REST API accepts simple JSON payloads, making it ideal for quick task creation.

from todoist_api_python.api import TodoistAPI
todoist = TodoistAPI(os.getenv('TODOIST_API_TOKEN'))
def add_task(description, due_date=None):
todoist.add_task(content=description, due_string=due_date)
prompt = "User mentioned needing to finalize the quarterly report by Friday. Generate a Todoist task description and due date string."
result = call_gpt5(prompt)
if result['action'] == 'create_task':
add_task(result['payload']['description'], result['payload']['due'])

Because the model returns structured data, the bridge code stays tiny and reliable.

#Deploying and Running Your Agent

For a personal assistant you can run the script locally, but a cloud function or a lightweight container gives you always‑on availability.

• Option 1 – Local Scheduler: Use cron (Linux/macOS) or Task Scheduler (Windows) to invoke the script every 5 minutes.
• Option 2 – Serverless: Deploy to a platform like AWS Lambda or Google Cloud Functions. Expose a single HTTP endpoint that receives natural‑language commands from your phone.
• Option 3 – Docker: Wrap the code in a Docker image and run it on a cheap VPS. This isolates dependencies and simplifies updates.

Whichever route you choose, monitor usage quotas in the OpenAI dashboard to avoid unexpected charges.

#Best Practices and Security Tips

• Scope your API keys. Limit the Gmail and Calendar scopes to read/write only what the assistant needs.
• Validate model output. Even with JSON formatting, double‑check that the action field matches an allowed operation before executing.
• Rate‑limit calls. Insert a short sleep (e.g., 1 second) between consecutive GPT‑5 requests to stay within free‑tier limits.
• Encrypt secrets. Store API keys in a vault or use environment‑variable managers like dotenv.
• Log responsibly. Record only timestamps and action types, never full email bodies, to respect privacy.

#Next Steps

Now that you have a working prototype, experiment with additional integrations—Slack for instant notifications, Notion for knowledge bases, or even a voice front‑end using Speech‑to‑Text. The modular JSON contract you built makes swapping services painless.