Limitless Library MCP server
Commit Oct 28, 2026Enables AI agents to find, verify, and reuse previously completed work through exact component installation or source-free method guidance.
Also known as Univeracity/limitlesslibrary
- Stars
- 2
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Oct 28, 2026
- License
- Apache-2.0
What is Limitless Library MCP?
Limitless Library enables AI agents to find, verify, and reuse previously completed work through exact component installation or source-free method guidance.
Summary generated from the project's README
About Limitless Library MCP server
Developers using AI agents can prevent repetitive work by using Limitless Library to find and reuse previously completed components or methods. Instead of agents building every task from scratch, they can query a catalog to see if a compatible solution already exists. This process helps save time and tokens by providing three specific outcomes: an exact component for installation, a source-free method for guidance, or a safe abstention if no suitable match is found.
The system operates locally by default and requires no accounts, cloud services, or model APIs to function. For Linux users, it utilizes Bubblewrap to run receiver-owned verification programs in an isolated environment with no network access or inherited secrets. Users can connect agents through a bounded stdio MCP server using the limitless-mcp command, which exposes tools like limitless_query_before_work and limitless_register_method. This setup ensures that the receiving environment maintains full control over what is installed and how it is verified.
What you can do with it
- 1Preventing redundant agent tasksAn AI agent can check for existing solutions before starting a new task to avoid rebuilding work from zero.
- 2Installing verified code componentsA developer can use the exact adoption feature to install content-addressed bytes that are verified locally without overwriting existing files.
- 3Providing cross-language guidanceWhen a specific code file cannot be used due to language mismatches, the agent can receive a source-free method instead.
- 4Registering new reusable methodsAfter completing a task, an agent can register a concise method containing steps and applicability for future use.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 15, 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 reachableuniveracity/limitlesslibrary is public and reachablegithub.com/univeracity/limitlesslibrary ↗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-10-28github.com/univeracity/limitlesslibrary ↗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 GitHubStop rebuilding work that already exists
Without Limitless, an agent gets a task and starts from zero—even when another agent has already completed useful work. With Limitless, it checks first. One quick query can return a reusable component, a practical method, or an honest instruction to start fresh.
Without Limitless: task → rebuild from scratch With Limitless: task → check first → reuse what fits or start fresh
Finding prior work is only half the problem. Limitless also checks whether it is allowed, compatible, unchanged, and actually adopted. The receiving environment keeps control: it decides what may enter and verifies exact reuse locally.
At a glance
| Property | What it means |
|---|---|
| Three safe outcomes | Exact component, source-free method, or abstention |
| Receiver-owned proof | The receiving environment chooses installation paths and verification programs |
| Exact bytes | Content-addressed installation refuses overwrite and rolls back on failure |
| Fail-closed verification | No network, inherited secrets, or unsandboxed verifier fallback |
| Observed use | Delivery is not counted as reuse until receiver code invokes the supplied component |
| Real receiver facts | The agent host, work location, operating target, and place where success is observed can remain distinct |
| Local by default | The reference lifecycle needs no account, hosted service, or model API |
| Inspectable service trust | The optional connector pins service authority, policy, protocol, and signed results |
Try it now
| Starting point | Best for | What you get |
|---|---|---|
| Local quick start | Inspecting the complete lifecycle | Exact adoption, method guidance, and abstention with no account or hosted service |
| Public service | Searching and contributing to the shared Library | Anonymous activation, high-signal discovery, signed results, and reviewed public intake |
| Omarchy plugin | Omarchy users who want a native interface | A panel, bar widget, local catalog, agent connection, and optional service access |
Quick start
Try the complete local lifecycle from a source checkout. You need Python 3.11 or newer and Bubblewrap on Linux. On Debian or Ubuntu, install the one system dependency if it is not already present:
sudo apt-get install bubblewrap
Then run:
git clone https://github.com/Univeracity/limitlesslibrary.git
cd limitlesslibrary
./scripts/limitless
That is the only project command required. On first use, the launcher creates
an isolated environment under .limitless/, installs the small Python
dependency set, runs exact adoption, method guidance, and safe abstention, and
retains inspectable evidence under .limitless/quickstart. It requires no
environment activation, account, cloud service, model API, or model download.
The initial dependency installation may require package-index access; the
lifecycle itself runs without network access.
Check host readiness or retain another run at a path you choose:
./scripts/limitless doctor
./scripts/limitless demo --workspace ./limitless-demo
The demo refuses to overwrite an existing workspace. Later launcher runs reuse the isolated environment; running it without arguments keeps the original quick-start evidence and performs a disposable replay.
When integrating Limitless into another environment, install the checkout with
python -m pip install .; the installed commands are limitless and
limitless-mcp.
What the demo does
The bundled demo performs useful work on a structured agent audit event. It installs a narrow field-name redaction component and returns a sanitized copy while preserving non-sensitive data. It then demonstrates every safe outcome:
- Exact adoption — installs exact bytes without overwrite, runs receiver-owned checks, and proves receiver code invoked the component.
- Method guidance — returns a source-free method when Python bytes do not fit a JavaScript receiver.
- Safe abstention — withholds candidate details when no result fits.
The redactor protects configured structured field names; it is not a general scanner for secrets embedded in free text. See the local demo evidence map for the generated artifacts and manual inspection commands.
The terminal shows USEFUL LOCAL RESULT: the sample authorization and token
fields are redacted while its agent, action, and repository fields survive.
The same run reports a verified exact component, source-free guidance, and an
abstention. These are deterministic examples from the bundled local catalog.
Live service queries use the current public catalog and may correctly abstain.
How verified reuse works
For exact reuse, the receiver—not the capsule—controls the trust boundary:
- A query describes the requested capability and receiving environment.
- Policy and compatibility gates select at most one eligible result.
- The receiver chooses the destination and provides digest-bound checks.
- Limitless installs content-addressed bytes without overwriting receiver files.
- Bubblewrap runs the checks with no network, no inherited secrets, bounded resources, and a read-only receiver mount.
- Runtime evidence proves invocation and an append-only receipt binds the decision, component, verification, and disposition.
The agent's current machine is not automatically the receiver. A local receiver-environment profile can separately bind the agent host, the place being changed, one or more operating targets, and the environments or people capable of observing success. This covers cases such as a Linux-hosted agent building for Windows or an agent repairing a remote physical device. Only the host execution and target compatibility facts needed for service matching are projected across the network; work locations, hardware attributes, fact provenance, and physical-observation details stay local.
If exact bytes do not fit, only a source-free method may cross. If no safe candidate exists, Limitless abstains without disclosing one.
What is open here
- JSON Schemas for capsules, queries, decisions, receiver recipes, verifier results, adoption receipts, role-separated environments, and composite receiver evidence.
- A source-minimized local catalog with policy and compatibility checks.
- Exact-byte, no-overwrite installation with rollback on failure.
- Receiver-owned adherence and obligation verification under Bubblewrap.
- Python embedding and bounded stdio MCP connector surfaces.
- Versioned managed-service wire contracts, signed conformance corpora, and an explicitly activated, release-pinned HTTPS connector with anonymous installation identity, short-lived sessions, exact artifact staging, and resumable public contribution.
- Authoring and sealing commands, a one-command demo, conformance fixtures, and tests.
This repository is the inspectable foundation of the Limitless product. Its trust and foundation commitments are described in Open-source foundation.
Manual conformance proof
The smaller examples/ fixture exposes each primitive separately:
limitless validate-catalog --catalog examples/catalog
limitless query \
--catalog examples/catalog \
--request examples/requests/exact-python.json
Continue through installation, method guidance, abstention, and authoring in the conformance example.
MCP
Start the bounded local stdio server:
limitless-mcp --catalog examples/catalog
It exposes limitless_query_before_work and limitless_register_method and supports stateless MCP
2026-07-28 requests plus the 2025-06-18 and legacy 2025-03-26
initialization flows. Initialization-era clients complete initialize and
notifications/initialized before requesting a tool. Agents query before
material work. After checking a useful original result, they can register a
concise source-free method with steps, checks, applicability, and limits. The
method object follows the
canonical method example. The default stores
it privately under $XDG_DATA_HOME/limitless-library/methods
(or ~/.local/share/limitless-library/methods). Repeating the same registration
returns the same method reference. A registration does not assert that the
service has verified the method or accepted it into its catalog. Query results
remain a decision channel, not an artifact transport; installation remains an
explicit receiver-local operation.
An owner who wants new methods submitted to the public service can activate
the service, inspect and review its publication policy, then configure the MCP
command with both --submit-methods-publicly and
--public-method-policy-digest sha256:<reviewed digest>. This is standing
authorization to publish independently authored CC0 methods. The tool queues
submission in a separate process so normal task completion does not wait for
network or admission; the service still decides whether to admit each method.
Local-only is the default. The managed-service guide
explains status, retries, and revocation.
Python callers can use query_local(...) or McpStdioConnector. See
Protocol.
Connect an agent
This repository currently includes a direct setup adapter for Antigravity CLI
(agy). Other hosts can connect through the documented stdio MCP surface;
Omarchy users get verified setup adapters for Codex, Claude Code, Grok, and
Antigravity through the plugin described below.
Connect Antigravity to an explicit local catalog with one command:
limitless agent-connect antigravity --catalog /absolute/path/to/catalog
The command adds one named limitless-library stdio server to Antigravity's
documented MCP profile. It uses the exact Python environment that ran
limitless, so there is no separate executable to find or PATH assumption to
maintain. Restart Antigravity CLI, then its MCP instructions and the query and
method registration tools are available.
limitless agent-status antigravity
limitless agent-disconnect antigravity
The integration preserves all unrelated MCP entries. It keeps a small local ownership record containing only the profile path and its own command/args, and disconnect removes an entry only if those exact values still match. A pre-migration Antigravity installation uses its existing legacy profile; a migrated or new installation uses Antigravity's current global profile. This local connection neither activates the managed service nor sends a query until the agent calls the tool.
Use it with Omarchy
The verified Limitless Library plugin is live in the Omarchy marketplace. Install it from Omarchy's plugin interface, or use the marketplace command:
omarchy plugin add https://github.com/Univeracity/limitless-omarchy.git --enable
The plugin provides a native panel and bar widget, installs its private local runtime from the UI, connects the owner's selected agent where supported, and keeps service discovery opt-in. It supports both Omarchy customization and general agent work, so users do not need a second Limitless package.
See the Omarchy product page or inspect the plugin source.
Connect to Limitless Library service
Local use remains available without the service. The official client bundles
one content-addressed service locator. A single explicit action fetches the
exact credential-free profile, verifies its pinned identity, Ed25519 root and
rotation chain, accepted policy, and discovery document, then stores that trust
boundary locally. It also creates one service-specific signing key, verifies
the service's installation attestation, and obtains a short-lived anonymous
session. No account, downloaded profile, pasted token, or API key is required
for baseline public access. The examples below use an installed limitless
command; from a source checkout, use ./scripts/limitless instead.
limitless service-activate
limitless service-inspect
limitless service-query \
--request-id request:example-001 \
--objective "Verify prior work with receiver-owned checks and observed adoption" \
--receiver ./examples/receiver-context.json
# When the verified result selects an exact artifact:
limitless service-query \
--request-id request:example-002 \
--objective "Find an exact component compatible with this receiver" \
--receiver ./examples/receiver-context.json \
--artifact-output ./selected.bin
Inspect and adapt the service receiver example
to the actual target before querying. It declares an agent on Linux/x86_64;
it is not automatic host detection. execution describes the agent host,
targets describes where the work must fit, and allowedUse states its intended
use. For multiple targets, choose all-targets with selectedTarget: null, or
one-target with a declared target ID. The {constraints, toolchain} receiver
inside examples/requests/ belongs to local queries and cannot be passed as a
service receiver. The client builds fresh timestamps and a query digest; advanced
callers can still submit a complete current query with --request PATH.
The service accepts anonymous activation, queries, outcome evidence, and
public contributions. A contribution can contain an independently authored
source-free method or a canonical exact file bundle that keeps its declared
source license and notices. Both enter protected staging before admission;
only admitted releases become globally queryable. Advanced integrations may
still pass an owner-reviewed alternate profile with --profile. The client
validates root rotation, signed discovery, policy continuity, query binding,
compatibility, and the signed result before returning it. Remote failure yields
control back to local reuse. Connecting
alone never publishes a local capsule or silently installs selected work.
Exact remote artifacts move only after the caller supplies
--artifact-output: public immutable objects need no credential, while
protected objects use a signed capability header. Both lanes verify the
declared format, media type, length, and digest and create a new owner-only file
without overwrite.
Staging is not parsing, installation, or proof of adoption; those remain
receiver-adapter responsibilities.
Publication is explicit but account-free. After inspecting the service and
reviewing its advertised publication policy, publish the bundled source-free
method example with the exact policy digest shown by service-inspect:
limitless service-publish \
--draft ./examples/publication/publication.draft.json \
--accept-publication-policy-digest 'sha256:<reviewed-policy-digest>'
service-publish accepts only the files named by the draft, resolves them
relative to that draft rather than the current directory, and prepares a
signed, resumable owner-only state file before transfer. It negotiates digests
first, streams only missing bytes, and returns the admission state. That state
supports later status inspection and explicit withdrawal without storing a
credential in the draft or command line. A quarantined or rejected
contribution is reported honestly rather than mistaken for a network failure.
The client does not scan or upload a workspace. Artifact sources must already
be canonical
limitless.exact-file-bundle/1.0 payloads; the client verifies that shape
locally and binds it into the current signed publication intent. Method files
also require validated canonical JSON: sorted object keys, compact UTF-8 JSON,
and at most one trailing newline. The bundled method already meets that rule.
For a hand-formatted method, create a new canonical file locally:
limitless seal-method --draft ./my-method.json --output ./my-method.canonical.json
Name that new file in the publication draft's objects list. seal-method
does not connect or publish, and refuses to overwrite a file. Publication
rejects malformed or noncanonical methods before signing new state or uploading;
it never rewrites bytes already named by a resumable operation. Auxiliary
manifest and verification files retain their own byte contracts. See the
managed-service connector.
Authoring
The checked-in examples/authoring records omit derived digests. Seal them
only after payload and receiver-verifier review:
limitless seal-capsule \
--draft examples/authoring/capsule.draft.json \
--root examples/catalog/hello-component \
--output capsule.json
limitless seal-recipe \
--draft examples/authoring/recipe.draft.json \
--receiver examples/receiver \
--output recipe.json
Outputs are immutable: both commands refuse to overwrite an existing path.
Documentation
| Guide | Purpose |
|---|---|
| Local demo | Evidence map and manual inspection |
| Protocol | Local API and MCP contract |
| Managed-service connector | Explicit endpoint, trust, policy, and query boundary |
| Trust model | Security boundaries and failure behavior |
| Conformance | Required outcomes and fixture expectations |
| Release wheel source evidence | Reproduce and authenticate the distributed core wheel |
| Open-source foundation | Relationship between the open implementation and product |
| Examples | Primitive-by-primitive walkthrough |
Status and security
The current published release is 0.1.0a1 alpha. This repository is the open-source foundation of Limitless Library. The complete local lifecycle works without an account or hosted service and remains single-operator. Contained exact verification currently requires Linux and Bubblewrap; querying and method selection do not.
The official public service is usable now for anonymous activation, discovery, signed decisions and results, exact-artifact staging, outcome evidence, and reviewed public contribution. The private admission, ranking, managed-storage, and multi-tenant service implementation is intentionally outside this repository; its public wire contracts, connector, conformance fixtures, and trust checks are open here. Account-backed history and private group or organization coordination remain under development.
There is deliberately no unsandboxed verifier fallback. Querying and method
selection work without Bubblewrap; exact adoption fails closed if containment
is unavailable. Schemas and interfaces may change incompatibly before 0.1.0
stable.
Read the trust model before use. Report vulnerabilities according to SECURITY.md.
Contributing and license
Contributions should preserve fail-closed behavior, non-disclosure on abstention, and receiver ownership of verification. Start with CONTRIBUTING.md and the Code of Conduct.
Apache-2.0 licensed. See LICENSE and NOTICE.