ISO FileMaker Magazine

Your agent can see your data, adjust your table structure, and run your scripts, but the one thing FileMaker developers most want to hand over, writing and improving the script logic itself, is still locked away. The steps you spend hours composing live in a space no external model can simply open, and until you understand how that code leaves FileMaker and returns, every attempt to automate your scripting work runs into the same wall. This video walks every path that script logic currently has between the FileMaker you know and the agent world you are building into.

Watch each route in action, from the moment a copied script lands on the clipboard as XML, to a full export of the solution that gets split into individual files an agent can read by name, to a local companion server that carries modified logic back into the script workspace without you ever touching a paste key. You will see the tradeoffs of each method, what the agent actually receives, how much noise travels with it, and how an in-FileMaker plugin can shrink the entire round trip to a single conversation, complete with switches that decide whether the agent may execute scripts, modify them, or leave data alone.

This video goes into the decisions that make direct script work safe and repeatable, how to keep your instruction file from becoming a dumping ground, which guardrails belong on an agent with direct access to your machine, and how context windows change as you move from single scripts to long-running operations. It also maps what the platform itself is shipping, including the patch file approach for offline files and where direct integration for hosted solutions stands, so you know exactly what you can rely on today and what is coming down the road.

You have your agent set up, connected to your solution, and ready to work. Yet the seemingly minor choice of which model and effort level to run quietly decides whether agentic coding saves you money or drains it. The names providers use are designed to push you toward the most expensive option, and the more powerful a setting sounds, the more you pay for it. But most FileMaker work, from everyday scripts to schema changes to small enhancements, does not demand the deepest thinking model in existence. This video sorts out the confusion around model and effort selection so you can stop paying for capability you will never touch.

Watch the same kind of task cost several times more when run through an intermediary harness than when run straight from the provider, and see why that difference alone can reshape what you pick. You'll see how a mid-tier model at a moderate effort setting can handle real FileMaker scripts the way a flagship model does, and you'll learn the cheaper pattern that often beats a lower model pushed to a higher effort level: running actual scripts through a sandbox and comparing results before you commit. The video also traces the two roads script logic travels between FileMaker and an agent, from a clipboard copy of a script's XML to a full file export, and shows why the way code moves in and out of your solution shapes everything you can automate next.

This video covers the essentials of choosing models and effort and what keeps those costs predictable as your usage grows, how to test models against your own scripts before relying on them, which editor or terminal workflow fits the way you like to work, and the sandbox habits that keep experiments from touching a real solution. It also sets the stage for the bigger payoff. The next step in the series is where agents go from reading about your scripts to writing them directly, and knowing exactly what you should and should not be paying for today makes that investment far easier to justify.

Agentic coding has arrived, and there is no version of the future where it stays outside your FileMaker workflow, yet for most FileMaker developers it currently looks like a wall. Most every LLM ("agent") you can point at a project today works within a mental model of folders, plain text files, and version control, while everything you've built in FileMaker, your scripts, layouts, fields, and data, sits sealed inside a file that no model can simply open and inspect. This first video in the series takes that gap head on and shows why it exists, what it means for how your development process will evolve, and the groundwork you need before an agent can do anything useful with your solutions.

Watch as a dedicated project folder, a purpose-built internal FileMaker account, and a single markdown instruction file turn a general-purpose AI agent into one that can find your hosted solution, list every table it exposes, and execute scripts on request. You will see the hidden layers of your computer made visible, from the dot files that quietly govern each agent to the environment file that keeps credentials out of your version history, and you will watch the whole loop close when the agent connects through FileMaker's OData interface, reads the live structure of the solution, and runs a script without any manual plumbing. What used to mean hours of documentation and trial and error becomes a set of short, repeatable instructions that any agent you choose can follow.

This initial video establishes the connection, but the full series is where working with agents becomes a skill you can rely on. It continues with version control as the backbone of every project folder, reusable skills that extend what an agent can do, the quiet problem of drift as your solution outgrows the instructions you wrote for it, and the model and effort choices that decide how much you pay for the help you get. Taken together, the lessons turn agentic development from a novelty into a dependable part of how you build, test, and maintain FileMaker solutions.

If you still open the Script Workspace, click New Script, and wire your solutions together by hand, you are about to feel left behind. This tutorial confronts the uncomfortable reality that traditional FileMaker development has become slower and more tedious than the alternative, and explains why so many developers have already stopped working that way entirely. The conversation around AI and agentic tooling has moved past hype into daily practice, and FileMaker professionals who skip the fundamentals are going to find themselves struggling to keep pace with what their peers are already shipping.

You will watch the curtain pulled back on what is actually happening when you fire up one of the popular agentic coding tools, from the virtual machines and sandboxes quietly running on your computer, to the command line binaries doing the real work underneath. The video walks through how harnesses, models, and agents actually differ, where the hidden configuration folders live on your machine, how the context window grows with every single exchange, and why understanding privileges and configs unlocks essentially everything else. By the end of the walkthrough, the seemingly magical behavior of these tools becomes legible and predictable, which is exactly the footing you need before trusting an agent with your real FileMaker work.

The full version goes considerably deeper, covering how to run multiple agents in parallel through terminal splits and multiplexers, how to spawn dedicated sub-agents with their own scoped instructions, and how to use hooks to enforce deterministic behavior before and after every agent interaction. You will also see how to drive an active coding session from your phone through remote control, how local models reshape the cost and privacy calculus, and how all of this is converging on a plugin that exposes agentic capability directly inside your FileMaker solutions. This is the kind of foundational understanding that separates developers who simply use agents from developers who actually direct them with intent.