An Agent That Can Say "Unconfirmed"

Ask an AI assistant whether Synapse will enforce the date-time format on a string field, and you will get an answer. It will be fluent, it will cite draft-07's treatment of format as an annotation, it may even be correct — but you cannot tell, because the model would have produced an equally fluent answer either way. The honest response to that question is "unconfirmed," and unqualified fluency is the one register in which a language model struggles to say it.

Now ask the same assistant to produce a Synapse-ready schema, and the problem compounds. Trained on oceans of modern JSON Schema, it will emit a plausible document: $defs where the platform wants definitions, an exclusiveMinimum the platform's schema object has no field for, an $id in whatever shape the training data favored, maybe a hyphenated pre-release version that the registered-schema identifier cannot legally contain. Every one of those choices is statistically reasonable. Every one is wrong in a way that either fails at registration or — worse — registers and silently enforces less than intended.

This is why the synapse profile in CoreModels is built to be something an agent calls rather than something an agent imitates.

The tool call

CoreModels exposes its transform engine over the Model Context Protocol. An assistant connects to https://coremodels.example.com/mcp, authenticates via OAuth, and receives typed, self-describing tools. Two of them matter for this story.

transform_schema runs the full deterministic pipeline — decode the source, plan, validate through the universal gate, execute, encode — and accepts synapse as a target format, along with the three identity inputs: the Synapse organization, the schema name, and the semantic version for the registered-schema $id. The call is stateless; the project identifier scopes authorization and nothing else. What comes back is not a paraphrase but the output of an encoder whose keyword whitelist is the documented field set of the platform's JsonSchema REST object, whose identifier composition sanitizes each segment and falls back explicitly when a version is not a plain major.minor.patch, and whose every omission is written down.

generate_synapse_manifests produces the curation companions: from any schema the engine can decode, it emits per-type CSVs — the blank entry grid and the column dictionary with its value-set section, vocabulary terms carrying labels and parent links. It is stateless and read-only, and it can target a single type by name, which is precisely the granularity a conversation runs at: a user asks for "just the biospecimen sheet," and the agent can deliver exactly that without touching anything.

A refusal an agent can act on

Here is a small design decision that turns out to matter enormously for automation. If an agent — or the user instructing it — asks the engine to decode with the synapse format, the engine declines with a message that contains the remedy: a Synapse schema is plain draft-07 JSON Schema, so decode it with the jsonschema format.

For a human, that is a helpful error. For an agent, it is a recovery path. The assistant reads the refusal, switches the format key, and completes the task in the next call — no hallucinated workaround, no abandoning the request, no misreporting the capability to the user. Error messages that name the correct next action are agent infrastructure, and we write ours accordingly.

The ledger gives the agent its honest voice

Every result carries the lossiness ledger: typed records, each with a kind, a path, and a plain-English explanation. For an agent, this is the difference between hedging and reporting.

Without it, an assistant summarizing a conversion can only gesture — "some constraints may not be preserved." With it, the agent can state facts: the numeric step constraint on this element was stripped and is no longer enforced; the string-or-null union on that element was narrowed to string; the taxonomy's term hierarchy was flattened, and it survives in the manifest's value-set section.

And crucially, the ledger is where "unconfirmed" becomes a first-class answer. The open questions about the platform's validation behavior — null-unions, format enforcement, non-string enums — surface as records that say, in so many words, that the behavior is unconfirmed and the conservative representation was chosen. An agent relaying that record is being precise, not evasive. It can tell the user exactly which fields are affected, why explicit nulls will not validate, and what was emitted instead. The engine's honesty is transferable; the agent inherits it by quotation rather than manufacturing it by tone.

Grounding, then gating

The pattern extends past conversion. Once a schema lives in a CoreModels project, the same MCP surface offers read tools over the governed model — project summaries, node search, JSON validation against the stored schema, exports into a dozen formats. An agent answering "which columns are required, and which vocabulary drives the status field?" queries structured facts instead of re-reading schema text it may misparse, and its answers agree with the manifests and the registered schema because all three come from the same source.

What the agent cannot do is decide meaning. Writes to a governed model require admin rights held by the human, not eagerness held by the assistant. Mapping plans proposed by an AI pass the identical validation gate as hand-authored ones — one repair attempt at most, confidence scores read as advisory and never as permission — and that path requires elevated project membership because it sends schema content to an external model service, a fact the tool advertises rather than buries. And the final act in the Synapse story, registration under a bumped version, belongs to a person: the platform refuses to re-register an existing version, and deciding that a change deserves a new one is exactly the kind of judgment we route to humans on purpose.

The division of labor, stated once

Let the model do what models do: hold the conversation, draft the request, choose the words. Let the engine do what engines do: enforce a documented subset, compose a legal identifier, refuse cleanly, itemize every loss. Let the person do what people must: read the ledger, approve the meaning, register the version.

An agent wired this way produces Synapse artifacts that are boring in the best sense — correct where correctness is documented, conservative where it is not, and accompanied, always, by the list of what changed. Fluency is what the assistant brings. "Unconfirmed" is what we make sure it can say.

To connect an assistant and try the tools, see the MCP quickstart in the CoreModels docs.