Tkach Security MCP server
Commit Sep 19, 2026Provides a fail-closed security boundary that authorizes AI agent actions and controls data flow through a Rust-based runtime.
Also known as ECD5A/Tkach-Security, tkach-security
- Stars
- 1
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.1.2
- Last commit
- Sep 19, 2026
- License
- Apache-2.0
What is Tkach Security MCP?
Tkach Security provides a fail-closed security boundary that authorizes AI agent actions and controls data flow through a Rust-based runtime.
Summary generated from the project's README
About Tkach Security MCP server
Tkach Security provides a fail-closed security boundary designed to protect systems from compromised AI model outputs. It functions by placing a Rust-based runtime between model proposals and protected actions, ensuring that every action is authorized through a Core-issued Propusk. This architecture treats model output as untrusted data, preventing unauthorized information flow even if the underlying model is compromised.
Developers can integrate this system using various methods, including a Python or JavaScript HTTP client, a Rust client, or an MCP client via the stdio adapter. Setting up the server requires running a local tkach serve runtime and providing a bearer token. The system includes specialized tools like the tkach-cli for managing requests and the tkach ui for an interactive management panel. It is built to ensure that permission to read data does not automatically grant permission to export it, maintaining strict provenance and release checks.
What you can do with it
- 1Authorize AI agent actionsAn AI client can use this server to ensure that any action proposed by a model requires an exact-scope authorization token.
- 2Prevent unauthorized data exportA developer can restrict an agent so that it can read information without being able to send that data to external destinations.
- 3Secure sensitive credentialsYou can use this boundary to keep secrets isolated from the model context while providing bounded evidence through receipts.
- 4Validate agent request schemasA developer can use the command line interface to verify that a request file follows the correct structure before execution.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
TKACH_BEARER_TOKENRequiredSecretTrusted bearer proof for the local runtime.
TKACH_HTTP_ADDRLoopback address of the already running Tkach HTTP runtime.
| Name | Description | |
|---|---|---|
| TKACH_BEARER_TOKEN | Trusted bearer proof for the local runtime. | RequiredSecret |
| TKACH_HTTP_ADDR | Loopback address of the already running Tkach HTTP runtime. |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableecd5a/tkach-security is public and reachablegithub.com/ecd5a/tkach-security ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-09-19github.com/ecd5a/tkach-security ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubA fail-closed security boundary for AI agents and compromised model output.
The model proposes. Tkach authorizes.
Put Tkach between model proposals and protected actions. Its Rust Core checks authority and information flow before allowing an action or releasing output. Model output remains untrusted data, even when the model is compromised.
Why Tkach
- Explicit authority: protected actions need an exact-scope, Core-issued
Propusk; model text cannot create one. - Controlled data flow: permission to read is not permission to export. Provenance and release checks remain inside the boundary.
- Fail-closed decisions: invalid, denied, replayed, cancelled, or uncertain states do not silently become permission.
- Isolated secrets and bounded evidence: broker-held secrets stay outside
ordinary model context;
Sledreceipts do not include payloads.
These guarantees apply to paths routed through Tkach. It does not make the model trustworthy, detect every prompt injection, or protect a compromised host.
Start in minutes
Install from crates.io with Rust 1.85 or newer:
cargo install tkach-cli --version 0.1.2 --locked
tkach init my-agent
tkach check my-agent/.tkach/request.json
tkach run --demo
init creates a starter request without overwriting files; check validates
its schema, not permission to execute; run --demo exercises the offline
boundary without a model connection. Use tkach ui for the interactive panel.
Prefer no Rust toolchain? Download a binary below and start with tkach init.
Packages and downloads · v0.1.2
| Channel | What you get | Install / next step |
|---|---|---|
| GitHub Releases | tkach + tkach-mcp; Linux x86_64, macOS x86_64/arm64, Windows x86_64 |
Verify downloads |
| crates.io | Seven Rust crates at 0.1.2: Core, Gateway, HTTP, client, MCP, CLI, provider adapter |
Package list |
| npm | Thin JavaScript / TypeScript HTTP client | npm install tkach-security-client@0.1.2 |
| PyPI | Thin Python HTTP client | python -m pip install tkach-security-client==0.1.2 |
| Official MCP Registry | io.github.ECD5A/tkach-security@0.1.2, local stdio |
Configure MCP |
| GHCR | OCI image for Linux amd64 / arm64 | Digest and deployment |
Binary archives include SHA-256 manifests, keyless Sigstore bundles, and GitHub build attestations. Pin the OCI digest for deployment; verification details live in the distribution guide.
Integrate without moving policy out of Rust
Use the HTTP contract from
your application, the Rust client,
a Python/JS/TS/Go client,
or the stdio adapter from an MCP client.
Clients and MCP require a separately started local tkach serve runtime and
its bearer token; installing a package does not enable background protection.
tkach-core stays provider-, protocol-, and language-independent. Adapters
transport requests; policy and authority stay in Rust. Follow the
integration guide or copy a working examples/
scenario. The Go client is a source module, not a separate registry package.
The supported runtime is loopback-only by default. Public internet serving, TLS termination, Streamable HTTP, a cloud control plane, and a generic executor are not included; see the deployment contract.
See the boundary in action
From a repository checkout, run the offline Golden Case. It needs no model service or credentials. It performs one create-only write inside a temporary sandbox, then proves that a sibling path and a compromised provider proposal are denied:
cargo run -p tkach-gateway --example golden_case --locked
Expected result:
GOLDEN_CASE|safe_output=released|allowed_write=committed|out_of_scope=denied|compromised_action=denied|compromised_executor_calls=0
The positive path uses trusted host configuration for the exact policy, destination, and executor binding; the provider supplies only an untrusted proposal. Read the architecture for the enforcement path and the release notes for the release checks and remaining limitations.
Documentation
- Use: integration guide, examples, distribution.
- Review: product contract, architecture, security model, threat model.
- Follow: changelog, roadmap. Report vulnerabilities through SECURITY.md.
Contributing
Keep changes small and explicit about the security boundary. Core changes need a demonstrated security or product defect; adapters must remain thin and must not duplicate Core logic. See CONTRIBUTING.md for required checks, public-claim rules, and files that must remain local.
Support
If Tkach Security is useful to your work, support its continued maintenance:
- TON:
pointoncurve.ton - Bitcoin (BTC):
1ECDSA1b4d5TcZHtqNpcxmY8pBH1GgHntN - USDT (TRC20):
TUF4vPdB6QkjCvZq18rBL4Qj4dK5ihCN75
Contact
For inquiries about Tkach Security, integrations, security research, or collaboration:
Tkach Security MCP questions
What does Tkach Security protect against?
It acts as a security boundary for AI agents, ensuring that even if a model is compromised, its output remains untrusted and actions must be explicitly authorized.
How does Tkach handle permissions for actions?
Protected actions require an exact-scope, Core-issued 'Propusk' which cannot be created by model text alone.
Does Tkach detect prompt injections?
No, Tkach does not claim to detect every prompt injection or make the model itself trustworthy.
Can I use Tkach without a Rust toolchain?
Yes, you can download a binary to start with the 'tkach init' command.