systemprompt.io was authored by Edward Burton, an enterprise engineer who has been deep in AI infrastructure since the beginning. The software is copyright protected and registered with the USPTO. This is the fruit of that work.
The code is the pitch. Published on crates.io and source-available for enterprise buyers. If it does not survive scrutiny, nothing else matters.
Enterprise-grade AI governance infrastructure.
systemprompt.io is the touchpoint between your AI and everything it does. A single Rust binary that holds every governance decision, every audit trail, every policy evaluation, and every agent interaction in one place.
It was built to answer one question: can infrastructure hold an enterprise-grade standard across a hundred thousand lines of Rust without drifting? The answer sits in the codebase. Architectural consistency across every module, every extension, every migration. One standard, applied everywhere, every time.
Engineered to survive scrutiny.
This codebase has undergone technical due diligence at some of the largest tech companies on the planet. It has had human code reviews from Rust maintainers. The standard it was built to is the standard it is held to.
Architecture, security, performance, compliance, and documentation are not afterthoughts. They are dimensions the code is validated against continuously. The output is infrastructure that survives an audit, a load test, and a code review on the same day.
Rust. PostgreSQL. One binary. Everything.
One language. One database. One binary: ~50MB.
No microservices. No Kubernetes required. No Redis. No Kafka. No ElasticSearch. No message queues. No service mesh.
Air-gap capable from day one. Copy the binary to a server with PostgreSQL. Start it. That is the deployment.
The live load test tells the story: 200 concurrent governance requests, each performing JWT validation, scope resolution, three rule evaluations, and an async database write. Sub-5ms p50 latency. Sub-10ms p99. Zero garbage collector pauses. Throughput that supports hundreds of concurrent developers on a single instance. This scales to any organisation of any size, and we have been through technical due diligence with some of the biggest in the world.
Rust's type system is the first governance layer. If it compiles, the governance pipeline is structurally sound. The compiler is the strictest code reviewer on the team, and it runs on every build.
Standards first. Always.
systemprompt.io is built on open standards that will outlive any single company. MCP from Anthropic for agent-tool communication, implemented natively, not proxied. A2A from Google for agent interoperability. OAuth2 with OIDC for authorization. WebAuthn for passwordless authentication.
Not proprietary protocols. Not vendor lock-in. Standards that were being written while this code was being compiled.
Production-proven.
This is not a prototype.
systemprompt.io runs the website you are reading right now. The marketplace. The MCP servers. The content pipeline, the analytics, the admin dashboard, the demo request form, the background job scheduler. One Rust binary plus one database. For everything.
Multiple production deployments, all running without a hitch. The load testing results matter more than the unit test count. This binary handles concurrent agent sessions, parallel MCP tool calls, real-time analytics aggregation, and content serving from a single process. The question is not whether the tests pass. The question is whether the system holds under sustained production load. It does.
The binary you evaluate from the template is the same architecture that serves this page.
Our Achilles heel is our strongest strength.
One author. One binary. Full IP ownership.
Enterprise vendors have layers. Sales teams, solutions architects, legal departments, procurement processes, partner channels, advisory boards. Fifty people between you and a decision.
We have zero.
No board to approve your deal. No committee to review your integration request. No partner channel taking a margin. No investor dictating terms. The person you talk to is the person who wrote the code.
The complexity is in the code, not the organisation. We are simple. We own all the IP. We are happy to do a deal. There is no complexity here unless you bring it.
Any doubts about the code? Good.
That is my favourite type of conversation.
I am happy to open the codebase, walk through the architecture, and talk sharp. Show the governance pipeline. Show the load testing results. Show the extension traits. Show the MCP implementation.
The code is the pitch. If it does not survive scrutiny, nothing else matters.
What you get.
Source-available under BSL-1.1. Full source code, auditable, modifiable. Converts to Apache 2.0 after four years. Compile-time Rust extensions, your code compiled into your binary. Provider-agnostic across Anthropic, OpenAI, Google, and local models. Skills and agents stored as portable YAML and Markdown.
Annual licensing with support and updates included. For enterprises that require ownership terms, we are open to structured agreements that grant IP rights under specific circumstances.
Evaluate it yourself.
No sales call required. No sandbox to request. No demo to schedule.
- Clone the template from GitHub. Run it with Docker or compile from source. Full governance pipeline.
- Read the documentation. Deployment guides, API reference, and configuration are public.
- Book a meeting when ready. Once you have seen it running, let's talk implementation, licensing, or custom integrations.
Contact
Edward Burton, Author
