Where This Idea Came From‍

I realized that I was often making the same correction over and over when using AI agents to help with content creation. I asked my agent how it might use Fulcra to improve this process.

‍
Problem‍

I draft with a set of agents, one per format, and each one was already instructed to verify its claims against our public repos before writing anything.
The problem was that the information was scattered. Some lived in public source code, exact and checkable. Some only existed as an answer I'd have to give in person. None of it was written down anywhere an agent could read.

‍
So the instruction to "verify" had nothing to verify against.  What I actually needed was one place that stated what was true — and was honest about where the truth ran out.

‍
Steps to Solve

• Split the facts into two kinds: ones a script can pull from source code, and ones only a person can answer.
• Tried listing our repos through the GitHub API, got rate-limited, switched to downloading tarballs instead — which worked for our three main repos.
• Wrote a generator that reads our tool definitions, our API's public methods, and a capability table from a README.
• Fixed two bugs in the first generated version: one where complex parameter types were splitting incorrectly, and one where a row was silently dropped.
• Looked for our connector list in the public source, couldn't find it anywhere.
• Wrote everything into a file in Fulcra, clearly marking anything the code couldn't answer as unverified.
• Gave all my agents the same short instruction to read that file first, using a script that made sure the instruction only got inserted once.

‍

Solution‍

The file has two halves, with different levels of trust on purpose.‍

The derived half is generated automatically — our tools, our API surface, our product's core concepts. It's pulled fresh from source code, so it's never something an agent just remembers.‍

The stated half is answered by a human, and anything still unknown is marked unverified rather than left blank. Connectors, pricing, availability now have a marker (unverified) that forbids incorrect entries.

Both halves live in one file in Fulcra, so it works across all my agents. The instruction itself is short: read the file before drafting, treat the derived half as fact, never assert anything marked unverified, and describe data sources generally until someone confirms specifics. It also includes a fallback: if an agent can't reach the file, it checks the source code directly instead of guessing.

Two of my eight agents already had their own verification steps that checked the repos live on every run. I kept those in place and just pointed them to the new file first, rather than ripping out something that already worked.

‍
Result

• Our tools and API are documented in one place, generated from source instead of recalled from memory.
• No hardware brand or integration gets mentioned unless it's actually real — the honest answer instead of the convenient one.
• All my agents read the same file, so a correction only has to happen once instead of eight times.
• The generated half updates itself automatically — a new feature or renamed setting shows up without me touching any agent.

‍

The result:‍

My agents now know the difference between what they actually know and what they were about to make up.