How Stratia Works With AI Agents

Most software is a destination. You open the app, you click around, you do the work with your own two hands. Stratia is that - a web app with a Launchpad, a Roadmap, a Research Notebook. But it is also something less common: a system an AI agent can operate on your behalf.

The reason matters. A growing number of students, parents, and counselors don't start their day in a college-counseling app. They start it in an AI assistant - Claude or ChatGPT - because that's where they already think out loud, paste a transcript, or ask "is this list realistic?" The honest question for any modern tool is: can the assistant the user already trusts actually do something useful with my product, or does it just describe it from the outside?

Stratia's answer is to expose itself over MCP - the Model Context Protocol - as a set of tools an agent can call. Not a chatbot bolted onto the marketing site. The real thing: your college list, your fit analyses, your profile, your roadmap, your research notebook, reachable by the agent you already use, scoped to you, with safe write actions included. The app is one client. Your agent is another. They read and write the same data.

This paper explains how that works - the connector, the tool surface, the Playbook that puts it one tap away from inside the app, the safety model, and the round trip that takes analysis your agent does and lands it back inside your app.

MCP is an open standard for connecting AI agents to tools and data. An agent that speaks MCP can call any MCP server's tools through the same interface - so a single connector serves every client Stratia supports today - Claude, ChatGPT, Glean, and GitHub Copilot - without a separate integration for each. They speak the same protocol; Stratia builds one bridge.

Stratia's connector is a small, always-on service that Stratia runs for you - nothing to download or install. The setup is one step: in your assistant you add a single URL and sign in once with Google. From that moment your agent has a Stratia toolset.

The sign-in does double duty. The Google account you authenticate with is your Stratia identity - the verified email is the only key the server uses to decide whose data a given tool call touches. There is no separate API key to paste, no shared secret to leak, and no way for one student's session to read another's data. Every tool call resolves "who is this?" from the signed-in identity behind the request, every time.

Everything runs on open standards, so any assistant that supports connectors can join without special setup. You don't configure abilities one by one - you connect once, and the agent discovers everything it can do for you.

Connecting isn't the interesting part - what the agent can do once connected is. The connector exposes more than 50 purpose-built tools today, in three families.

Read - see everything the app sees. Your full academic profile; your college list with each school's status and current fit category; a complete fit analysis for any school (scored factors, gap analysis, strategy, timeline, essay angles, scholarships); your Major Map and each school's major chances; your full phase-grouped roadmap timeline and upcoming deadlines across your whole list; the verified summer-programs catalog with your personalized picks; essays, financial-aid packages, the scholarship tracker; and the entire university knowledge base by search or by school. An agent can answer "what's due in the next two weeks and which of those am I behind on?" without you copy-pasting a thing.

Act (write tools) - make safe changes. Add or remove a college from your list, recompute a fit against the latest data, update a single profile field, build your whole profile from a document, add tasks to your roadmap (after you approve them - this powers the per-phase roadmap review), or record a real admission decision, including which major you applied to. These change your data, so they're labeled as such and the agent asks before doing anything destructive (see the next section).

Remember (research notebook) - keep the work. Save a piece of analysis to your Research Notebook, search and revisit earlier notes, get a bird's-eye overview of what you've researched and what's missing, pin your master strategy, refresh notes built on older data, and turn a note's recommendations into roadmap tasks.

The surface is deliberately comprehensive. The design goal was that an agent should be able to do anything you could do yourself in the app - not a thin read-only slice that forces you back into the UI for every real action.

A tool surface is only useful if you know what to do with it. Most people don't want to learn to write good prompts for a college-counseling agent - they want the useful moves to be one tap away. That's what the Playbook is: the app side of the same bridge.

Instead of a blank chat box, you get a categorized, searchable library of ready-made questions and actions, grouped by what you're actually trying to do - plan your year, build your profile, pressure-test your fit, find money. Each one is a real move, not a canned FAQ: build my profile from this transcript, compute my fit for these schools and add them to my list, compare two colleges on admit odds and cost, find scholarships I qualify for and save the plan.

Pick one and it opens in your agent, already written and pointed at your real data. Your agent runs it through the connector's tools, and - because of the round trip below - whatever it produces lands back in your app. The Playbook doesn't just answer: the actions it launches change your real Stratia data - a profile gets built, a fit gets computed, a college gets added, a note gets saved.

And it's yours to shape. You can save your own questions and whole categories, so the workflows that work for you are one tap away next time. Connecting Claude or ChatGPT is a one-time step on the Agents page; after that, the Playbook is where you drive them - without ever leaving Stratia to remember what to type.

Handing an AI agent write access to anything is a fair thing to be nervous about. The connector is built so the agent can never do more than you could do yourself, and never touches anyone else's data.

Only ever you. Who you are comes from your own sign-in, and there is nothing an agent can say or send that makes a request read as somebody else. Not signed in, nothing happens. Your data is reachable by exactly one identity: yours. And the access is yours to end: one click on the Agents page disconnects any agent, immediately.

Honest labels on every action. The agent always knows what it's about to do. Anything that only looks at your data announces itself as that; anything that would change your data announces itself as a change, and the genuinely destructive ones (removing a college, deleting a note) require your confirmation first. Analyses - recomputing a fit, generating a major map or strategy - run when your request calls for them, never speculatively; and your list only changes with schools you name.

Hard limits, and an off switch. There is a ceiling on how much an agent can change or generate in one stretch, so a confused assistant cannot run away with your account. And the whole bridge can be switched off at once if it ever had to be, while the rest of Stratia keeps working. The connection is also hardened against the known ways malicious websites try to hijack AI assistants.

None of this is visible to you in normal use. That's the point: the safe path is the default path, and the agent is structurally prevented from coloring outside the lines.

This is the part that makes the connector more than a fancy read-only API. Analysis your agent does flows back into your app.

Think about what normally happens when you ask an assistant to compare two schools or draft an application timeline: you get a great answer, and then it evaporates into a chat history you'll never scroll back to. The work was real; the persistence wasn't.

The connector closes that loop. When your agent produces something worth keeping - a college comparison, a timeline, essay angles, a scholarship plan, a deep-dive, an overall strategy - it saves the analysis straight into your Research Notebook with one tool call. The note lands in your app, linked to the exact colleges it's about (so it shows up on their cards), tagged, and labelled with who wrote it and which year's admissions data it was working from - so if the numbers underneath it move on, the note can tell you.

It doesn't stop at a note. The agent can turn a note's recommendations into roadmap tasks - each task linked back to the note that produced it - so research becomes action on your Plan, not a paragraph you have to re-read and manually transcribe. And it works in the other direction too: hand your agent a transcript, résumé, or activities list, and it reads the document and fills out your Stratia profile from it, without wiping what you had already put there.

The throughline: you do the thinking with the agent you like, and the durable artifacts - notes, tasks, a profile - accumulate inside the product where the rest of your application work already lives.

An agent-operable system can quietly become a system that lies about its own provenance - claiming everything was written by one model, or pretending a prediction was better than it was. Stratia is built to resist both.

Honest attribution. Every note is labeled with the real assistant that made it. A note written through ChatGPT says ChatGPT; one written through Claude says Claude; anything else keeps its own name or a neutral "an AI agent" label. It is never silently relabeled as something it wasn't. When you look back at your notebook, you can trust the byline.

Workflows as repeatable recipes. When your agent saves analysis, it can also capture how it got there - your original request in your own words, plus the ordered steps it ran ("pulled my profile," "got Duke & UCSD fit," "compared against my list"). That turns a one-off result into a recipe you can re-run later as your data changes. Across all users, these step-sequences are aggregated - stripped of any personal data - into Popular Workflows, so the system can surface the research patterns that actually help, rather than guessing.

A ledger of what really happened. This is the sharpest example. Your agent can record the real outcome - accepted, waitlisted, denied, deferred, enrolled - for each school, kept cleanly separate from where you are in the application process. Stratia checks those outcomes against the fit categories it predicted and recalibrates. A tool that confidently scores your chances should be willing to be checked against reality - the Decision Ledger is how it stays checked.

The short version of everything above:

• One URL connects your agent - Claude, ChatGPT, Glean, or GitHub Copilot signs in once, and your assistant holds 50+ purpose-built admissions tools.
• It reads your real data - profile, list, fits, deadlines - and writes real artifacts back: research notes, roadmap tasks, list changes.
• Nothing is lost to the chat scroll - analysis lands in your Research Notebook, plans land on your Roadmap, and every change is attributed.
• The Decision Ledger stays honest - agent-assisted or not, every fit call is checked against what actually happened.

The architecture is the means. Here's what changes for the person at the keyboard:

• Use the assistant you already use. Your real college data shows up inside Claude or ChatGPT - not behind one more login you have to remember to open.
• Or don't leave the app at all. The Playbook hands you the useful moves - build my profile, compute my fit, compare two schools, find scholarships - one tap away, already pointed at your data. No prompt-writing required.
• The agent reasons over your real situation, not a generic guess. It reads your actual profile, your actual list, your actual fit scores - so "is this realistic?" gets an answer grounded in your data, not in averages.
• Nothing good gets lost. The comparison, the timeline, the strategy your agent produced lands back in your app, linked to the right schools and ready to act on - instead of scrolling away in a chat log.
• It stays yours. Everything an agent does is done as you, and anything destructive asks first. The agent can do what you could do - and nothing more.
• It's honest about itself. Notes are labeled by who wrote them, the steps are repeatable, and the system checks its own predictions against what really happened.

Stratia's bet is that the future of this kind of tool isn't a walled app you have to live inside. It's a well-defined, safe surface that the AI you already trust can operate - turning your assistant into a genuine collaborator on the one application process that's hard to get a second try at.

Find your fit. Build your plan. Tell your story.