AI agents are getting better at using software.
We give them tools, APIs, MCP servers, memory, RAG, and increasingly sophisticated ways to interact with applications.
But I think there is another direction we should explore:
Instead of only teaching AI how to use software, we should also make software easier for AI to understand.
The Context Problem
A lot of agent tasks don't happen in a single session.
An agent creates something today. The user modifies it tomorrow. Then they come back and ask the agent to continue working on it.
The agent now needs to understand the current state of the artifact.
Memory seems like an obvious solution, but it is fragile. The agent might remember where something was, what it created, or what a particular value meant. But the user may have moved it, renamed it, or changed it.
Code agents have an interesting advantage here.
If an agent writes a piece of code today and comes back tomorrow, it can simply inspect the repository again. Function names, types, comments, file names, and the code itself provide a lot of context.
The artifact is partially self-describing.
But what about something like an Excel workbook?
Spreadsheets Are Hard for AI to Understand
Consider a DCF model.
It may contain assumptions, revenue projections, a cash flow statement, WACC calculations, terminal value, and several scenarios.
Suppose the user says:
"Change the terminal growth rate to 3%."
An AI agent working with a conventional .xlsx file may have to search through sheets and cells to figure out which value the user means.
A cell like F23 = 2.5% doesn't tell the agent much by itself.
A human can look at the surrounding labels, formatting, and layout and immediately understand it.
The spreadsheet contains the information.
It just isn't explicitly structured for the AI.
So instead of making the agent remember more, perhaps we should make the software itself more understandable.
Making Spreadsheets AI-Friendly
This is the idea behind Blocks in LogiSheets.
A Block is a structured region of a spreadsheet. It has things like:
- Fields — what each column represents
- Keys — stable identities for records
- refName — a stable name that software can reference
- Description — semantic information about the Block
- Permissions — what operations are allowed
So instead of an AI seeing:
F23 = 2.5%
it can see something closer to:
Block: DCF Assumptions
refName: dcf_assumptions
Fields:
tax_rate
wacc
terminal_growth
revenue_growth
Now the agent doesn't need to infer the meaning from cell coordinates.
And because the identity is attached to the structure rather than the physical location, moving rows or columns doesn't necessarily destroy that context.
This is an important distinction:
Cell coordinates describe where something is.
Metadata describes what something is.
For humans, location is often enough.
For AI, semantics are much more useful.
Software Should Be AI-Understandable
I don't think this is only a spreadsheet problem.
As AI agents become another type of user, software may need to expose more of its semantic structure.
The question shouldn't only be:
"How can AI use our software?"
It should also be:
"How should we design software so AI can understand it?"
MCP helps AI access software.
But access is only half of the problem.
We also need software that exposes its own structure and meaning.
That's what I'm exploring with LogiSheets: an Excel-compatible spreadsheet where structured Blocks make spreadsheets easier for both humans and software to work with.
And logisheets-mcp exposes that structured model to AI agents through MCP.
The goal is simple:
Don't make AI remember everything about the artifact.
Make the artifact understandable by AI.
LogiSheets: https://github.com/logisky/LogiSheets
logisheets-mcp: https://github.com/logisky/logisheets-mcp