MESH_CONNECTOR

How it's put together, in plain terms.

This is the page for whoever asks the hard questions — your IT lead, your controller, or you at two in the morning. Nothing here is a black box, because a system you can't inspect is a system you can't trust with your ERP.

One server, one customer, one vault

Your Prophet 21 database never leaves your network. The MeshCore server reaches into it over a connection you control — a VPN, an IP allow-list, or a small on-premise relay if you would rather not expose SQL at all.

MeshCore architecture. Top: your network, holding the Prophet 21 SQL Server and the P21 Transaction API. A single guarded link, marked VPN or allow-list and carrying guarded writes only, connects down to the MeshCore server. That server holds six components: channels for Telegram, email and Teams; the agent gateway running one profile per agent; the P21 connector with verified recipes and the healer; the Obsidian memory vault; the scheduler; and the skills packs. Beneath them runs an append-only audit log with secrets held at mode 0600 and nightly snapshots. Below, a git push and pull link connects to your own private GitHub repository holding the vault, which you can open in Obsidian on your own PC.

The six pieces

The agent gateway

The runtime your agents live in. One profile per agent, each running as its own service, so several agents can share a box without sharing an identity. Adding an agent doesn't disturb the ones already working.

The agents

Each is two plain files: its role and standing rules, and a profile of your business — who's who, your timezone, your tools, how you like things done. We ship a template with the non-negotiable rules already baked in; you fill in the personality at onboarding.

Skills

One job, described in a folder, with its action class declared. That's what makes the approval model enforceable rather than aspirational — the class is decided when the skill is written, not by the model in the moment.

Memory

A private GitHub repository holding an Obsidian vault, cloned onto the server and pulled every three minutes. Ingested source material stays read-only; the agent maintains its own summaries; the rules file stays yours to edit. You can open the whole thing on your PC.

The scheduler

Scheduled jobs are declared in a file in your vault, so the timetable is something you can read, review, and change. Every run writes to the audit log, and anything that actually did something writes a line you can find later.

The Prophet 21 connector

Reads go through a read-only login or OData. Writes go only through the Transaction API recipes we have verified live. Install-specific values — company id, location ids, hostnames — live in your own configuration file and never in the shared product.

From first call to running on its own

The shape of a MeshCore rollout. The read-only weeks are not a formality — they are how you find out whether the agent understands your business before it is allowed to change anything in it.

Discovery

Which three recurring jobs cost you the most, what channels your team actually uses, how we reach your P21 install, and who approves a guarded write.

Provision

We stand up your server, create your vault repository, install the packs, write your configuration, register your channels, and run the acceptance tests.

Week one: read-only

The agent runs briefs, monitors and draft-only skills. It writes nothing. You name it, correct what it has misunderstood, and tune how it talks.

Week two onward: writes

We enable one guarded write at a time, each verified live on your install before it is switched on. No big-bang cutover.

Running

We monitor your box — health, failed jobs, healer outcomes. Upgrades happen in a window you agree to.

If you leave

You keep the vault; it was always in your repository. We revoke the keys and destroy the server. No exit project, no data to extract.

Every lesson your install teaches makes the product better

When a Prophet 21 write fails in a new way, the healer works out the fix, verifies it by reading the record back, and records it twice: once so the machine can apply it next time, and once as a written decision a person can audit.

Generalised lessons flow back into the product, stripped of anything identifying. Values specific to your install stay in your configuration and are never folded into the shared pack. So the fifth MeshCore customer gets a connector that already knows what the first four ran into — and none of them can see each other's data.

That is the compounding asset here, and it is why the P21 knowledge is the part that would be hardest for anyone else to copy.

  • A write fails with a real P21 error
  • The healer matches it to a known fix, or stops
  • It retries, then reads the record back to confirm
  • The lesson is written down, machine-readable and human-readable
  • Credit limits, deleted records and silent no-ops are stop conditions, never retried around

Bring your hardest question to the call.

Network path, credentials, what happens when it gets something wrong, what you're left holding if you cancel. Those are the right questions and we have answers for all of them.

Book a discovery call Read the security model