Building a Personal AI Agent in a couple of Hours

been so stunned by how briskly particular person builders can now ship actual and helpful prototypes.

Instruments like Claude Code, Google AntiGravity, and the rising ecosystem round them have crossed a threshold: you may examine what others are constructing on-line and notice simply how briskly you may construct in the present day.

Over the previous weeks, I’ve began reserving one to 2 hours a day completely for constructing with my AI-first stack:

• Google AntiGravity
• Google Gemini Professional
• Claude fashions accessed by means of AntiGravity

This setup has basically modified how I take into consideration prototyping, iteration velocity, and what a “private AI agent” can realistically do in the present day. Extra importantly, it pulled me again into hands-on coding and constructing, one thing I had personally sacrificed as soon as my function at DareData shifted towards administration and orchestration moderately than execution.

Individually, this revolution has been a blessing somebody who was at all times going to float towards administration roles. It removes the trade-off I had accepted: that rising an organization meant abandoning constructing fully. I now not have to decide on between constructing and managing, they really reinforce one another.

However, there’s a broader implication right here for people who find themselves “simply” growing. If AI brokers more and more deal with execution, then pure implementation stops being sufficient. Builders can be pushed (whether or not they need it or not) towards coordination, decision-making, and.. administration — one thing that particular person contributors hate by coronary heart. In different phrases, administration abilities turn out to be a part of the technical stack, and AI brokers are a part of the context being managed.

What stunned me most is how transferable my current administration abilities turned out to be:

• Guiding the agent moderately than micromanaging it
• Asking for outcomes as a substitute of directions
• Mapping, prioritizing, and pointing the gray areas

In follow, I’m managing and coordinating a digital worker. I can deeply affect some components of its work whereas remaining nearly fully unaware of others — and that’s not a bug, it’s a large characteristic. In my private AI assistant, for instance, I can cause clearly concerning the backend, but stay largely clueless concerning the frontend. The system nonetheless works, as a result of my function is now not to know all the things, however to steer the system in the correct route.

That is straight analogous to how I coordinate individuals inside the corporate. As DareData grows, we don’t rent replicas of founders. We deliberately rent individuals who can do issues we can’t do, and, over time, issues we’ll by no means study deeply sufficient to do effectively.

Sufficient self-reflection on administration. Let’s take a look at what I’m constructing as a result of that’s what you might be right here for:

• A private AI assistant designed round my precise routines, not a generic productiveness template. It adapts to how I work, assume, and make choices.
• A cell app that recommends one music album per week, with no conventional advice system. No comfort-zone reinforcement and that helps me develop my listening zones.
• A cell sport constructed round a single character progressing by means of layered dungeons, developed primarily as a artistic playground moderately than a business product.

The attention-grabbing half is that, whereas I’m snug coding many of the backend, front-end growth is just not a ability I’ve — and if I have been pressured to do it myself, these tasks would decelerate from hours to days, or just by no means ship.

That constraint is now largely irrelevant. With this new stack, creativeness turns into the actual bottleneck. The price of “not figuring out” a complete layer has collapsed.

So, in the remainder of this submit, I’ll stroll by means of my private AI assistant: what it does, the way it’s structured, and why it really works for me. My aim is to open-source it as soon as it stabilizes, so others can adapt it to their very own workflows. It’s at present very particular to my life, however that specificity is intentional, and making it extra basic is a part of the experiment.

Meet Fernão

Fernão Lopes was a chronicler of the Portuguese monarchy. I selected a Portuguese historic determine intentionally — Portuguese individuals have a behavior of attaching historic names to nearly something. If that sounds stereotypically Portuguese, that’s intentional.

Fernão is Portuguese however truly speaks English, name it a modern-day chronicler for the twenty first century.

At this level, I’m doing two issues I often keep away from: anthropomorphizing AI and leaning into a really Portuguese naming intuition. Think about it a innocent signal of me turning older.

That apart, what does Fernão truly do for me? The most effective place to begin is his entrance web page.

Fernão is a cool-looking dude who at present handles 5 duties:

• Day Schedule: plans my day by pulling collectively calendars, to-dos, and aims, then turning them into one thing I can comply with.
• Writing Assistant: helps me evaluation and clear up drafts of weblog posts and different texts.
• Portfolio Helper: suggests firms or ETFs so as to add based mostly on rebalancing wants and what’s happening within the macro world (with out pretending to be a crystal ball).
• Monetary Organizer: extracts spending from my financial institution statements and uploads all the things into the Cashew app, saving me from yet one more activity that took me about 3 to 4 hours month-to-month.
• Subscriptions & Reductions: retains observe of all my subscriptions and surfaces reductions or advantages I most likely have however by no means bear in mind to make use of.

On this submit, I’ll concentrate on the Day Schedule app.

In the meanwhile, Fernão’s Day Schedule does three easy issues:

• Fetches my calendar, together with all scheduled conferences
• Pulls my to-dos from Microsoft To Do
• Retrieves my private Key Outcomes from Notion

All of that is related by means of APIs. The concept is simple: day by day, Fernão seems at my constraints, priorities, and commitments, then generates the very best schedule for me.

To generate a schedule within the front-end is fairly straightforward (all of the front-end was vibe coded). Right here is the generate schedule button:

As soon as I hit Generate Schedule, Fernão begins cooking within the background:

The steps are then, so as: fetching my calendar, duties, and Notion knowledge.

The following level can also be the place primary coding literacy actually begins to matter, not as a result of all the things the next code doesn’t work, however as a result of you’ll want to perceive what is going on and the place issues might finally break or want enchancment.

Let’s begin with the calendar fetch. In the meanwhile, that is dealt with by a single, gigantic perform created by Claude that’s fully unoptimized.

def get_events_for_date(target_date=None):
    """
    Fetches occasions for a selected date from Google Calendar by way of ICS feeds.
    
    Args:
        target_date: datetime.date object for the goal day. If None, makes use of in the present day.
    
    Returns a listing of occasion dictionaries.
    """
    # Hardcoded calendar URLs (not utilizing env var to keep away from placeholder points)
    CALENDAR_URLS = [
        'cal1url',
        'call2url'
    ]
    
    LOCAL_TZ = os.getenv('TIMEZONE', 'Europe/Lisbon')
    
    # Get timezone
    native = tz.gettz(LOCAL_TZ)
    
    # If no goal date offered, use in the present day
    if target_date is None:
        target_date = datetime.now(native).date()
    
    # Create datetime for the goal day boundaries
    day_start = datetime.mix(target_date, datetime.min.time()).change(tzinfo=native)
    day_end = day_start + timedelta(days=1)
    
    # Debug: Print the date vary we're checking
    print(f"n[Debug] Checking calendars for date: {target_date.strftime('%Y-%m-%d')}")
    print(f"  Begin: {day_start.strftime('%Y-%m-%d %H:%M %Z')}")
    print(f"  Finish: {day_end.strftime('%Y-%m-%d %H:%M %Z')}")
    print(f"  Timezone: {LOCAL_TZ}")
    
    all_events = []
    
    # Fetch from every calendar
    for idx, cal_url in enumerate(CALENDAR_URLS, 1):
        calendar_name = f"Calendar {idx}"
        print(f"n[Debug] Fetching {calendar_name}...")
        
        strive:
            # Load calendar from ICS URL with enough timeout
            r = requests.get(cal_url, timeout=30)
            r.raise_for_status()
            cal = Calendar(r.textual content)
            
            events_found_this_cal = 0
            total_events_in_cal = len(record(cal.occasions))
            print(f"  Whole occasions in {calendar_name}: {total_events_in_cal}")
            
            # Use timeline to effectively filter occasions for goal day's date vary
            # Convert native occasions to UTC for timeline filtering
            day_start_utc = day_start.astimezone(timezone.utc)
            day_end_utc = day_end.astimezone(timezone.utc)
            
            # Get occasions in goal day's vary utilizing timeline
            days_timeline = cal.timeline.overlapping(day_start_utc, day_end_utc)
            
            for e in days_timeline:
                if not e.start:
                    proceed
                    
                # Get occasion begin time
                begin = e.start.datetime
                if begin.tzinfo is None:
                    begin = begin.change(tzinfo=timezone.utc)
                
                # Convert to native timezone
                start_local = begin.astimezone(native)
                
                # Debug: Print first few occasions to see dates
                if events_found_this_cal < 3:
                    print(f"  Occasion: '{e.identify}' at {start_local.strftime('%Y-%m-%d %H:%M')}")
                
                # Get finish time
                finish = e.finish.datetime if e.finish else None
                end_local = finish.astimezone(native) if finish else None
                
                all_events.append({
                    "title": e.identify,
                    "begin": start_local.strftime("%H:%M"),
                    "finish": end_local.strftime("%H:%M") if end_local else None,
                    "location": e.location or "",
                    "description": e.description or ""
                })
                events_found_this_cal += 1
            
            print(f"  [OK] Discovered {events_found_this_cal} occasion(s) for goal day in {calendar_name}")
            
        besides requests.exceptions.RequestException as e:
            print(f"  [X] Community error fetching {calendar_name}: {str(e)}")
            proceed
        besides Exception as e:
            print(f"  [X] Error processing {calendar_name}: {kind(e).__name__}: {str(e)}")
            proceed
    
    # Type by begin time
    all_events.kind(key=lambda x: x["start"])
    
    # Print all occasions intimately
    if all_events:
        print(f"n[Google Calendar] Discovered {len(all_events)} occasion(s) for {target_date.strftime('%Y-%m-%d')}:")
        print("-" * 60)
        for occasion in all_events:
            time_str = f"{occasion['start']}-{occasion['end']}" if occasion['end'] else occasion['start']
            location_str = f" @ {occasion['location']}" if occasion['location'] else ""
            print(f"  {time_str} | {occasion['title']}{location_str}")
        print("-" * 60)
    else:
        print(f"n[Google Calendar] No occasions for {target_date.strftime('%Y-%m-%d')}")
    
    return all_events

As a Python developer, all of the print statements give me the ick. However that’s an issue for the following part of Fernão: refactoring and optimizing the code as soon as the product logic is stable.

That is additionally the place I actually see the human + AI dynamic working. I can instantly spot a number of methods to enhance this perform (scale back verbosity, minimize pointless latency, clear up the circulate) however doing that effectively nonetheless requires time, judgment, and intent. AI helps me transfer quick; it doesn’t change the necessity to know what extraordinary seems like.

For now, I haven’t spent a lot time optimizing it, and that’s a acutely aware alternative. Regardless of its tough edges, the perform does precisely what it must do: it pulls knowledge from my calendars and feeds the assembly info into Fernão, enabling all the things that comes subsequent.

Subsequent, Fernão pulls my duties from Microsoft To Do. That is the place my every day to-dos dwell (the small, concrete issues that must get achieved and that give construction to a selected day). All of that is configured straight within the Microsoft To Do app, which is a core a part of my every day workflow.

When you’re curious concerning the broader productiveness system behind this, I’ve written about it in a associated submit on the brother of this weblog (Wait a Day) linked below.

So, let’s take a look at one other verbosed perform:

def get_tasks(target_date=None):
    """
    Fetches duties from Microsoft To Do for a selected date (duties due on or earlier than that date).
    
    Args:
        target_date: datetime.date object for the goal day. If None, makes use of in the present day.
    
    Returns a listing of activity dictionaries.
    """
    CLIENT_ID = os.getenv('MS_CLIENT_ID', 'CLIENT_ID_KEY')
    AUTHORITY = "https://login.microsoftonline.com/shoppers"
    SCOPES = ['Tasks.ReadWrite', 'User.Read']
    
    # Setup persistent token cache
    cache = SerializableTokenCache()
    cache_file = os.path.be a part of(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), '.token_cache.bin')
    
    if os.path.exists(cache_file):
        with open(cache_file, 'r') as f:
            cache.deserialize(f.learn())
    
    # Authentication with persistent cache
    app = PublicClientApplication(CLIENT_ID, authority=AUTHORITY, token_cache=cache)
    accounts = app.get_accounts()
    
    end result = None
    if accounts:
        end result = app.acquire_token_silent(SCOPES, account=accounts[0])
        if not end result or "access_token" not in end result:
            for account in accounts:
                app.remove_account(account)
            end result = None
    
    if not end result:
        circulate = app.initiate_device_flow(scopes=SCOPES)
        if "user_code" not in circulate:
            print(f"[MS To Do] Didn't create system circulate: {circulate.get('error_description', 'Unknown error')}")
            return []
        if "message" in circulate:
            print(circulate['message'])
        end result = app.acquire_token_by_device_flow(circulate)

    if not end result or "access_token" not in end result:
        print(f"[MS To Do] Authentication failed: {end result.get('error_description', 'No entry token') if end result else 'No end result'}")
        return []
    headers = {"Authorization": f"Bearer {end result['access_token']}"}
    
    # Get date boundaries for goal date
    # If no goal date offered, use in the present day
    if target_date is None:
        from datetime import date
        target_date = date.in the present day()
    
    # Convert date to datetime in UTC for comparability
    now = datetime.now(timezone.utc)
    target_day_end = datetime.mix(target_date, datetime.max.time()).change(tzinfo=timezone.utc)
    
    # Fetch all lists
    lists_r = requests.get("https://graph.microsoft.com/v1.0/me/todo/lists", headers=headers)
    if lists_r.status_code != 200:
        return []
    
    lists_res = lists_r.json().get("worth", [])
    all_tasks = []
    
    # Fetch duties from all lists with server-side filtering
    for task_list in lists_res:
        list_id = task_list["id"]
        list_name = task_list["displayName"]
        
        # Easy filter - simply get incomplete duties
        params = {"$filter": "standing ne 'accomplished'"}
        
        tasks_r = requests.get(
            f"https://graph.microsoft.com/v1.0/me/todo/lists/{list_id}/duties",
            headers=headers,
            params=params
        )
        
        if tasks_r.status_code != 200:
            proceed
        
        duties = tasks_r.json().get("worth", [])
        
        # Filter and rework duties
        for activity in duties:
            due_date_obj = activity.get("dueDateTime")
            
            if not due_date_obj:
                proceed
                
            due_date_str = due_date_obj.get("dateTime")
            if not due_date_str:
                proceed
            
            strive:
                due_date = datetime.fromisoformat(due_date_str.cut up('.')[0])
                if due_date.tzinfo is None:
                    due_date = due_date.change(tzinfo=timezone.utc)
                
                # Embrace all duties due on or earlier than the goal date
                if due_date <= target_day_end:
                    # Decide standing based mostly on the right track date
                    target_day_start = datetime.mix(target_date, datetime.min.time()).change(tzinfo=timezone.utc)
                    
                    if due_date < target_day_start:
                        standing = "OVERDUE"
                    elif due_date <= target_day_end:
                        standing = f"DUE {target_date.strftime('%Y-%m-%d')}"
                    else:
                        standing = "FUTURE"
                    
                    all_tasks.append({
                        "record": list_name,
                        "title": activity["title"],
                        "due": due_date.strftime("%Y-%m-%d"),
                        "significance": activity.get("significance", "regular"),
                        "standing": standing
                    })
            besides Exception as e:
                proceed
    
    # Print activity abstract
    if all_tasks:
        print(f"[MS To Do] {len(all_tasks)} activity(s) for {target_date.strftime('%Y-%m-%d')} or overdue")
    else:
        print(f"[MS To Do] No duties due on {target_date.strftime('%Y-%m-%d')} or overdue")
    
    # Save token cache for subsequent run
    if cache.has_state_changed:
        with open(cache_file, 'w') as f:
            f.write(cache.serialize())
    
    return all_tasks

This perform retrieves a full record of my duties for the present day (and overdue from earlier days) — right here’s an instance of how they appear in to-do:

After pulling duties from To Do, I additionally need Fernão to know the place I’m making an attempt to go, not simply what’s on in the present day’s record. For that, it fetches my aims straight from a Notion web page the place I’ve the important thing outcomes for my yr.

Right here’s an instance of how these aims are structured:

• the primary column reveals my baseline in the beginning of the yr,
• the final column defines the goal I wish to attain,
• and the column on the correct tracks my present progress.

The pattern under embody what number of weblog posts I wish to write for you this yr, in addition to the entire variety of books I intention to promote throughout my three titles.

This provides Fernão broader context on what to precedence within the duties, as you’ll see within the immediate to create the schedule.

Btw, whereas penning this submit, I ended up including a small widget to the app. If we’re constructing a private assistant, it would as effectively have some persona.

So I requested Gemini:

“Are you able to add a enjoyable animation whereas the app is retrieving calendar occasions, checking to-dos, and pulling Notion knowledge? Perhaps a small widget of Fernão stirring a pot, with the caption ‘Fernão is cooking’.”

As soon as this spherical finishes, duties and calendar occasions are efficiently collected and displayed in Fernão’s entrance finish (a pattern of the duties and conferences for my day is proven under).

And now the enjoyable half: with calendars, duties, and aims in hand, Fernão composes my total day right into a single, magical plan:

07:30-09:30 | Gymnasium
09:30-09:40 | Verify Timesheets on Odoo (Due: 2026-02-04)
09:40-09:55 | Overview Duties in To-Do - [Organization Task] (Due: 2026-02-04)
09:55-10:15 | Learn Feedly Stuff - [News Catchup] (Due: 2026-02-04)
10:15-10:30 | Write tradition doc, inspiration: https://pt.slideshare.internet/slideshow/culture-1798664/1798664 (Due: 2026-02-04)
10:30-10:45 | Reply LinkedIns - [Organization Task] (Due: 2026-02-04)
10:45-11:00 | Verify Looker (Due: 2026-02-04)
11:00-11:30 | This Week in AI Put up (Due: 2026-02-04)
11:30-12:00 | Put together Podcast Decoding AI
12:00-13:00 | Podcast Decoding AI - Ivo Bernardo, DareData (Occasion)
13:00-14:00 | Lunch Break
14:00-14:30 | Candidate 1 (identify hidden) and Ivo Bernardo @ Google Meet (Occasion)
14:30-18:00 | Put together DareData State of the Union
18:00-18:30 | Candidate 2 (identify hidden) and Ivo Bernardo @ Google Meet (Occasion)
18:30-19:00 | Candidate 3 (identify hidden) and Ivo Bernardo @ Google Meet (Occasion)
19:00-19:30 | Candidate 4 (identify hidden) and Ivo Bernardo @ Google Meet (Occasion)
19:30-20:00 | Candidate 5 (identify hidden) and Ivo Bernardo @ Google Meet (Occasion)
20:00-20:15 | Verify Insider Buying and selling Indicators for Inventory Concepts https://finviz.com/insidertrading?tc=1 (Overdue)
20:15-20:30 | Advertising Timeline (Overdue)
20:30-21:00 | Dinner Break
21:00-22:00 | Ler
22:00-22:15 | Shut of Day - Overview and prep for tomorrow

That is a type of moments that genuinely feels a bit magical. Not as a result of the know-how is opaque, however as a result of the result is so clear. A messy mixture of conferences, duties, and long-term objectives turns right into a day I can truly execute.

What makes it much more attention-grabbing is how easy the ultimate step is. After all of the heavy lifting is finished within the background (calendar occasions, to-dos, aims), I don’t orchestrate a posh pipeline or chain of prompts. I exploit a single immediate.

That one immediate takes all the things Fernão is aware of about my constraints and priorities and turns it into the day you’re about to see.

identify: daily_schedule
description: Generate a every day schedule based mostly on calendar occasions and duties
mannequin: gemini-2.5-flash-lite
temperature: 0.3
max_tokens: 8192

variables:
  - date_context
  - events_str
  - tasks_str
  - context
  - todo_context
  - auto_context
  - currently_reading
  - notion_context
  - is_today
template: |
  You're my private AI scheduling assistant. Assist me plan my day!
  **TARGET DATE:** Planning for {date_context}
  **EVENTS (Fastened):**
  {events_str}
  **TASKS TO SCHEDULE:**
  {tasks_str}
  **MY CONTEXT:**
  {context}
  **TASK CONTEXT (how lengthy duties usually take):**
  {todo_context}
  **AUTO-LEARNED CONTEXT:**
  {auto_context}
  **CURRENTLY READING:**
  {currently_reading}
  **RESULTS & OBJECTIVES (from Notion):**
  {notion_context}
  **SCHEDULING RULES:**
  1. **Can not schedule duties throughout calendar occasions** - occasions are mounted
  2. **Obligatory breaks:**
     - Lunch: 12:30-13:30 (reserve when potential)
     - Dinner: 20:30-21:00
     - Enjoying with my cat: 45-60 minutes someplace scattered across the day
  3. **Job becoming:** Intelligently match duties between occasions based mostly on out there time
  4. **Time estimates:** Use the duty context to estimate how lengthy every activity will take
  5. **Working hours:** 09:30 to 22:00
  6. **Begin the schedule:** {is_today}
  
  **YOUR JOB:**
  1. Create an entire hourly schedule for {date_context}
  2. Match all duties between occasions and breaks
  3. **Prioritize duties based mostly on my Outcomes & Goals from Notion** - concentrate on what issues most
  4. Be conversational - should you want extra data a few activity, ask me!
  5. **Save learnings:** If I provide you with context about duties, acknowledge it and say you may bear in mind it
  **FORMAT:**
  Begin with a pleasant greeting, then present the schedule on this format:
  ```
  09:30-10:00 | Job/Occasion
  10:00-11:00 | Job/Occasion
  ...
  ```
  After the schedule, ask if I would like any changes or should you want clarification on any duties.
  Generate my day's schedule now, thanks!

And with this, Fernão is unquestionably cooking:

This has been a genuinely enjoyable system to construct. I’ll preserve evolving Fernão, giving him new tasks, breaking issues, fixing them, and sharing what I study alongside the way in which right here.

Over time, I additionally plan to put in writing sensible tutorials on tips on how to construct and deploy related apps your self. For now, Fernão lives solely on my machine, and that’s prone to stay the case. Nonetheless, I do intend to open-source it. Not as a result of it’s universally helpful in its present type (it’s deeply tailor-made to my life), however as a result of the underlying concepts is likely to be.

To make that potential, I’ll must summary instruments, modularize performance, and permit options to be turned on and off so others can form the assistant round their very own workflows, moderately than mine.

I may have constructed one thing related utilizing Claude Code alone. I didn’t. I wished full management: the liberty to swap fashions, combine suppliers, and finally run Fernão on an area LLM as a substitute of counting on exterior APIs. Possession and suppleness matter extra to me than comfort right here.

When you have been constructing a private AI assistant, what duties would you give it? I’d genuinely like to listen to your concepts and attempt to construct them inside Fernão. Go away a remark as this challenge continues to be evolving, and out of doors views are sometimes the quickest solution to make it higher.