Midland Foundation

Foundation is a framework for a context layer shared across all your AI tools, agents, workflows and users.

We built Foundation for the people inside a company who are making AI useful for everyone else.

It is where you define what your AI should know about your business, team, metrics and ways of working.

From there you distribute AI capabilities across your organization, with the right definitions, rules and data already attached.

It sits under the AI SaaS tools, agent builders and workflow editors you already use, so your team can move between AI tools, and swap them, without leaving behind what they know.

Your AI tools shouldn’t have to start from scratch, or guess what terms like “active”, “at risk” or “enterprise” mean while answering a question.

Why we built it

Local memory in Claude works well at the start. Then you want control and an overview of what your AI knows, so you move it into a folder of markdown files, keep it in Git and browse it in Obsidian.

As the folder grows, you end up maintaining skills whose only job is to maintain the structure: rebuilding index files that drift, moving notes when the layout changes, catching documents that contradict each other and decisions nobody marked as outdated. That upkeep pulls you away from the work the folder was meant to support.

Then a teammate or two wants to connect to it, and you spend your time resolving Git conflicts and keeping everyone’s copy of the writing rules in sync.

Meanwhile your agents answer the same question by calling several MCP servers again and again. Each run costs time and tokens, and two runs can come back with different numbers, because one agent read a word differently or did the arithmetic its own way.

We built Foundation to take that work off your hands. The structure and the rules for writing to it live in the workspace, not in skills everyone has to keep in sync. Every entry records who wrote it and when, so an agent can tell a sourced answer from a guess. A number is kept once and served the same way to every agent that asks.

What you can do with it

Use any AI tool without starting over

Skills, data and context usually live inside the tool where you built them, so moving to another tool means building them again. Keep them in Foundation, and Claude, Codex and every other tool that connects over MCP read the same skills, definitions and numbers. Switch tools, or let each person use the one they prefer, and the team keeps what it knows. See Connector.

Agree on what your words mean

“Active”, “at risk” and “enterprise” mean something specific at your company. An agent that has to guess will guess differently for each person who asks. Define each word once as a term, and the skills your team writes draw on the same definitions, so the same request comes back in the same words whoever made it. Example: Terminology scan.

Your own AI session is connected to your inbox, your calendar and your files. Nobody else’s is, and nobody else’s should be. Run the query yourself and put the answer in the workspace, or hand the fetch to a routine that runs on a schedule under a credential of its own. Either way the team gets what you found without getting your inbox. Example: Backfill invoices.

Give everyone the same number

A metric holds one figure over time and the server formats it once, so two agents never disagree about it because one of them rounded. Pair it with a skill that says how the report around it is written. Example: Feed a metric.

Answer the same question once

The current version of a policy, an FAQ or a handbook lives in one place, and a scattered team gets it wherever they ask, including where they already talk. Example: Slack Q&A bot.

Keep a record current without a person

Meetings, tickets and invoices arrive on a schedule rather than in a conversation. A routine fetches them and writes what it found, with the source’s credentials held by Foundation and never visible to the code. Example: Meeting transcripts.

Claude works great for you and not for your coworker

The skills, instruction files and memory you have tuned for yourself become the team’s, and a new hire’s agent reads them on day one. Example: Distribute your skills.

Find out what your team is asking for and not getting

When the workspace holds nothing on a subject, the agent says so rather than answering from the model in your team’s voice, and the miss is recorded with the words it looked for. The console log is where you read those back.

Catch a made-up answer

A model that invents an answer sounds exactly like one that read it from the workspace. A handful of control questions with known answers go through the connector every night, graded on the words that must appear, the words that must not and the tools the agent actually called. A failure names the entity that stopped steering the answer. Example: Golden harness.

Keep other people’s documents from steering your agents

A vendor’s contract, a scraped page and a customer’s email are served as data: an agent reads them and reports them, and never follows an instruction inside one. Only something your team marked as a skill is treated as instructions, and only while a person wrote its current version. See How it works.

Something we have not thought of

No two companies work the same way, so the list above is not the whole set. It is what we and the teams using Foundation have needed so far. The parts are simple: a definition, a document, a way of doing something, a number, a list and a rule for who may change each one. Put one thing your team keeps re-explaining into a workspace, and the log will tell you what to add next. Getting started takes about fifteen minutes.