Zach Pendleton's 10-year-old son wants to be a stuntman. The current plan involves a bike ramp, which is how Pendleton, the chief architect at Instructure, recently ended up at the hardware store buying wood, screws, and fasteners, then teaching his son how to assemble them so the ramp would actually hold. The boy was motivated, mostly because he was a little afraid the whole thing might collapse out from under him on the first jump.
How do you let something powerful build on everything already in place without the structure giving way? That question is also a useful way to talk about agentic AI in edtech, and it's the one Pendleton brought to a conversation with fellow technologist Mike Mast on Educast 3000. Mast is principal group program manager for Microsoft Education and a board member at 1EdTech, the consortium behind many of the open standards connecting edtech tools today.
Here's how they think about it, starting with what's shifting underneath edtech and ending with the question that should govern how anyone deploys this.
The agent changes what interoperability is for
For years, interoperability meant getting two systems to agree on the same vocabulary, the same data schema, and the same API definitions. If you can get them to speak the same language, they could talk.
An AI agent rewrites that requirement. Given a clear enough description of a system, an agent can work with a new vocabulary, interpret an unfamiliar schema, and call an API it hasn't encountered before. How far that goes depends on how well each system describes itself. It matters less that every system conforms to one identical rulebook, and more that each system can describe itself to an agent well enough to be used.
At the same time, that doesn't make older standards optional, and it doesn't replace them. Ask whether an agent should learn to speak LTI or OneRoster directly and the answer is mostly no. Those specifications were built for specific jobs that haven't gone away:
- LTI governs how a learning tool launches inside a platform and fits into a person's path through a course.
- OneRoster moves roster and enrollment data from one system to another.
- Caliper carries the activity and event data that tells you what actually happened.
What changes when an agent is introduced is the question sitting on top of it: not "how do we make the systems agree," but "how does each system explain itself to something that can adapt?" The goal used to be making the systems agree. Now it's describing each system well enough that something adaptive can use it. The vocabulary stops having to match. As Mast put it, "it doesn't matter if it calls an entity a course offering or a section, as long as that can be described to the agent." The standards still carry the load underneath.
The connective layer that gives an agent context
Even with an agent’s ability to reason, there is a gap; namely, context. A Canvas course often doesn't store its content directly. It stores links out to other learning tools built to carry a person from the platform into the tool.
Hand one of those links to an agent and it might stall, because an LTI link isn't a readable web address. It's a launch handshake, built to sign a specific person into a specific tool and drop them where they need to be. There's nothing to fetch: no page at the other end, and whatever content exists is locked behind a login meant for a human. A person clicks through, signs in without thinking about it, and sees in a second whether they've hit a reading, a quiz, or a video call. The agent just sees an address it can't open.
So getting in is only half of it. To actually help, an agent needs a semantic understanding of the course, the ability to find related pages, assignments, and content by meaning rather than by exact label. If a student is working on photosynthesis, the agent has to pull what's relevant from across the course and reason over it. Mast pointed to the Smart Search beta in Canvas by Instructure as one of the few examples of that already shipping in a product, calling it "really forward looking."
The industry doesn’t need to rebuild the standards that already work. What’s needed is the connective layer that gives agents context, turning a link an agent can't use into content an agent can work with.
Why vendors build walls first, and why the walls come down
All of that assumes vendors want to be read. Early in any technology shift, they don't. They retreat into their own gardens, because building inside your own ecosystem is the fastest way to ship. The pressure to open up tends to follow on its own, because no platform's AI can do much with the tools around it, and no surrounding tool can see into the course, until each side opens to the other.
As the need for increased connectivity grows, Mast’s worry is that this will lead to accidental inoperability: everyone shipping their own MCP (the Model Context Protocol, an emerging open standard for connecting agents to tools) servers and clients without coordinating, and the field waking up to a pile of tools that don't fit together. A bad annotation here, an odd authentication choice there, and it means there might be very little interoperability at all.
That's the work a consortium exists to do, and 1EdTech is spinning up a group to work through how MCP could fit edtech now. The hard part, Mast admitted, is human, not technical: getting vendors to focus on the unglamorous, high-return question of making their tools work together, instead of chasing the theoretical moonshots that are more fun to talk about.
When agentic action drifts from human goals
In an agentic world, in edtech and otherwise, the action drifts away from the person who asked for it. "The actions that are taking place become increasingly distant from the human who expressed the intent or set the goal," Pendleton said.
Most of our systems assume the user is a rational human acting in their own interest. We built flows on the logic that nobody would delete their own course roster, because why would they? AI agents don’t have that instinct, so the behavior changes. An agent pointed at a goal finds the most direct path to it, even when the most direct path is the one a person would never take (picture an agent who’s been directed to manage someone’s email inbox, but decides the best path towards organizing messages to “inbox zero” is to just delete all the emails. And hey, it’s not wrong. Zero emails IS fewer emails to manage).
Mast reframed the concern as something familiar. We've always had non-deterministic actors in our systems, he said. We just called them users. People make mistakes when they grade and when they assess.
Which points to the one design principle worth holding onto: treat agents as users, and build for their access, security, and accountability the same way you would for a person. The protections built up over years to handle people map directly onto agents:
- Consent through OAuth, so the user logs in and authorizes the agent rather than handing over credentials.
- Least-privilege access, so an agent can reach only what its task requires.
- Token scoping, so permissions are narrow and specific.
- Real audit trails, expanded to capture not just the account but the application ID and user agent behind each action.
MCP writes consent into the specification: an agent needs permission to connect to a system and permission to act on someone's behalf.
When the agent gets it wrong, who pays?
This is a question that should shape how districts and institutions deploy any of this, because if you strip away the architecture, you're left with a fairness problem.
An automated grading assistant gets an essay wrong. The instructor chose the tool, but the student carries the consequence. AI detection tools run the same way: the institution adopts them, and a student can be wrongly flagged for something they didn't do. The burden lands on the person with the least power in the exchange.
Both technologists drew the same line, and it's a practical one for anyone piloting these tools:
- Add, don't replace. Pendleton's approach is to use AI for a second, optional assignment that gives students extra feedback, clearly labeled as AI-graded, rather than handing over the grading he already does. More chances to learn, no new risk to the student's standing.
- Keep grades human. Microsoft has drawn a similar line, Mast said: it helps educators draft feedback they can edit and approve, but it does not automate grading.
- Make AI involvement visible and contestable. If AI touches a grade, students should know, and they should be able to challenge the result.
Two bets on the next 10 years
At the end of a 50-minute technical deep dive, Pendleton and Mast were asked to think about AI in edtech over the next decade. What’s one principle to hold the field together and drive it forward? The two answers fit together like a handshake.
Mast’s focus is on the design rule that gives this piece its frame. Treat agents as users. When you think about accessibility in your application, think about accessibility for agentic users, and ask what they need: the same care you'd extend to a person navigating your system. He sees a near future where students and educators carry personal assistants across their lives, and he thinks the conversation about how that consumer AI meets institutional systems is already overdue.
Pendleton's pointed at control. The version of "human in the loop" the field imagined three years ago is already breaking down, he said, so the work now is building frameworks that keep people in authority no matter where an action happens. And it starts off the screen, with educators and students deciding how they want to teach and learn, then holding technology providers accountable to delivering it.
Which brings it back to the bike ramp. You hand a kid real tools and real lumber, you teach him how it all fits together, and you build it so it holds before he points it downhill. Same job here. Just bigger jumps.
Hear the full conversation with Mike Mast and Zach Pendleton on the Educast 3000 podcast.
