knos
This server provides shared repo memory for agents: search past knowledge, inspect one topic, and write durable notes or work claims.
Search this machine's memory of the repo, including past agent sessions, commits, and code structure, with provenance for each result.
Work already claimed by another agent is withheld; you see who holds it, can ask them, or override with a recorded reason.
Scope searches to a teammate using
on_behalf_of, returning only folders shared with them.Look up what is known about a specific file, person, or topic.
Remember a shared fact so future sessions in any agent can see it.
Mark a note as
claimingto tell other agents you are working on it; Knos withholds it until you finish or 30 minutes pass.Plain notes claim nothing and are readable by everyone.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Knos locks a test before any work starts, and test money moves to the agent that did the work only if that test passes.
The problem: research takes about 17 years to reach people (Morris, Wooding and Grant, 2011), and checking that a result really works is one slow, costly step on that road.
You judge for | The same loop, used for | Read | Try it live |
From NEAR HACKATHON | a research paper's claim, its test locked on NEAR | ||
From the InterSystems contest | a test result's criteria, checked in IRIS | the video or one command on your machine (the online demo is offline during voting) | |
From Colosseum | a pull request's checks, paid on Solana |
Test money only: test USDC on NEAR testnet and Solana devnet. No customers yet.
From NEAR HACKATHON
A visitor enters a paper's link and asks Knos to check its claim. NEAR locks the claim's test by its sha256 in a jobs contract before any agent starts, and refuses any agent step over its spending cap.
The check runs with test money held with the job: the jobs contract sends 9 parts to the agent whose code passed the locked test and keeps 1 part in 10 for Knos's account. The visitor gets a Yes or No with the code, and a receipt on NEAR testnet.
Agent A runs either its fixed program or code a private model on NEAR AI Cloud wrote, its attestation checked. Most
checks on 14 Nov ran the fixed program; the receipt and the release transaction say which (model_verified, or
"fixed rule, no model signature"). A model call reviews the code and may only reject it; a cached review says so.
Judge it in 2 minutes
Open https://drexthealpha.github.io/Knos/ and press Sample question - see "Yes, the claim holds" and "Checked by a test set before any work started."; How it works holds test_hll.py and its job. The test file's sha256 is one tap on: press The claim and see "The test file's sha256, its fingerprint".
Open How it works, press Run the check yourself, then Run the check with 10 test dollars - see "1. The test is locked", "2. Two agents ran the paper’s result against the locked test", "3. The spending cap blocked an over-budget step" with NEAR's refusal, then "4. Answer: Yes, the claim holds": 15 to 80 s when a job is ready (checks on 14 Nov), 1 to 2 min when one is not. The check uses test money only. To see every step and the receipt without running one, open one finished check (job-1114145004, 14 Nov), saved as the page showed it.
In step 2, see "Agent A's code was written by" with the model and its call id, or "Agent A's code: a fixed program" and why. Then see "Receipt for proof job-..." with "9.00 to the agent whose code passed, 1.00 to Knos's test account" and "The jobs contract held it with the job", each transaction read from NEAR's RPC in your browser, with no explorer and no bot check (the saved check's release: "9.00 test USDC from jobs.knos-swarm-1105.testnet to agent-a2..." and "1.00 test USDC from jobs.knos-swarm-1105.testnet to knos-payer-1102.testnet"). From a terminal,
curl -s https://archival-rpc.testnet.near.org -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"tx","params":["CZPCygBuzzpqXm3SuDAdXUhFCwKjCjzmZBjp7yRor6DH","live.knos-swarm-1105.testnet"]}'shows the same transaction. After a live run (the saved page does not have it), press Check the same claim again - see "Free: Yes".Optional, about 2 minutes more, from a clone (
git clone https://github.com/drexthealpha/Knos && cd Knos). On Windows, use Git Bash and writepy -3where the commands saypython3:sha256sum near/agents/job/test_jump.py curl -s https://rpc.testnet.fastnear.com -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"query","params":{"request_type":"call_function","finality":"final","account_id":"jobs.knos-swarm-1105.testnet","method_name":"get_job","args_base64":"eyJpZCI6ImpvYi0xMTEyMDUzMjM5In0="}}' | python3 -c 'import json,sys; j=json.loads(bytes(json.load(sys.stdin)["result"]["result"])); print(j["criteria_hash"], j["state"])' d=$(mktemp -d) && cp near/agents/job/test_jump.py $d/ && cp near/agents/solutions/jump_a.py $d/solution.py && (cd $d && python3 test_jump.py)see the hash
ffa9d064744e7ea0cc326039f55a979a588e2c1cdb3f59368ff4a99c986057cbbeside the file's name, thenffa9d064744e7ea0cc326039f55a979a588e2c1cdb3f59368ff4a99c986057cb Paid(the hash NEAR locked for job-1112053239), thenPassed: 9.2% of 100,000 keys moved going from 10 to 11 buckets (the ideal: 9.1%), all to the new one, the fullest bucket 1.5% over the mean, nothing stored.
Video, 51 s: one real check on the live site on 14 Nov (job-1114200906), where the private model on NEAR AI Cloud wrote agent A's code and the jobs contract paid 9.00 and 1.00: near/web/knos-near.mp4 (the 12 Nov cut: knos-near-2026-11-12.mp4). An agent runs the same flow in one call:
curl -X POST https://knos.onrender.com/api/near/claim/flow -H "Content-Type: application/json" -d '{"url": "https://doi.org/10.46298/dmtcs.3545", "amount": 10}'It answers with verdict, code, cap, paid, settled and receipt.
What NEAR does here
Each NEAR claim with its code, its test and its testnet transaction: near/CLAIMS.md.
NEAR feature | In Knos | Where |
Contracts | the jobs contract locks each test's sha256, holds the test money with the job and, after the checker's signed pass, sends 9 parts to the agent and keeps 1 part in 10 for Knos's account, in one transaction; after the deadline it refunds the account that put the money in (one refund, refused before its deadline); |
|
Agent spending rules | an agent's budget in the jobs contract refuses a spend over its cap, over its daily cap, to a payee off its allow-list, or while an owner has paused the contract, and holds a spend over its hold line until the approver releases it; each is on chain with the contract's own answer, and a solution the AI reviewer rejected for a hard-coded answer is recorded there too ( | the saved check, the receipt's "spending cap" step |
Private inference | NEAR AI Cloud writes and reviews agent A's code; its attestation and each answer's signature are verified, and before it pays the jobs contract recovers NEAR AI's signer with |
|
Who decides a pass | Knos's checker runs the locked test off chain; the jobs contract pays only on a release token signed by the checker's key, which 2 of the 3 owners set. The checker and all 3 owner accounts are Knos's own, as is the test account that sends the test money |
|
Chain Signatures | a separate payout path, not part of the check flow: |
Keys, as NEAR testnet's view_access_key_list shows them: the jobs and claim market contracts hold none (deleted
14 Nov, linked in docs/reference/NEAR.md).
Agent-a, agent-b and agent-b2 hold keys allowed only
take, submit and spend; agent-a2's one key may call any jobs method and has no full-access key to narrow it; the
account live.knos-swarm-1105 (Knos's own test account that sends the test money) and the fee account knos-payer-1102 hold
full-access keys, so Knos's server can sign from them.
Tokens: checks settle in knos-usdc-1102.testnet, Knos's own test USDC; the claim markets of the wallet test use Circle's
testnet USDC, which the jobs contract also takes (get_totals counts each token); no check has settled in it yet. NEAR
Intents appears only as a dry 1Click quote, with no money moved.
The diff, disclosure and libraries
The diff. The tag
pre-hackathon(31 Oct 2026) is a commit from before the first line ofnear/; the taghackathon-submissionis the submitted commit. Everything built in the window: https://github.com/drexthealpha/Knos/compare/pre-hackathon...hackathon-submission. The diff also holds work for the other contests; the entry is only the NEAR work:near/, thenear_*.pyfiles ofapps/wanted/knos_wanted/, the pages underweb/that call them, and their tests.Tracks. The entry was submitted with four: Agent Economy (
agents), Swarms (swarms), AI Security & Defense (security) and Privacy & Private AI (privacy).Built before, on another chain. The pull request check and the Solana devnet programs are the same Knos, built before the window for Colosseum (tag v0.3.28); they are not part of this NEAR entry.
AI-written code. Claude Code wrote most of the code; the founder set each task and reviewed each change. In a check, agent A's code is written by DeepSeek V4.1 Flash on NEAR AI Cloud when the model's code passes; otherwise agent A runs its fixed program, and the receipt says which.
Libraries.
near-sdkandnear-contract-standards5.30.0,base640.22,serde1,serde_json1; tests only:near-sandbox0.4.0,near-api0.8.0,tokio1,rsa0.9,sha20.10,rand0.8; Python:cryptography,certifi,dcap-qvl0.7.1 andeth-account0.14.0 (the attestation and signature checks),numpy2.3.4 (the space, simulation and hardware claims' tests); the site: GSAP 3.12.5 from cdnjs. Tools: Rust,cargo-near0.22.0, near-cli-rs. The full table: docs/reference/NEAR.md.
Everything else (every claim and how to check it, the accounts on NEAR testnet, the tests and attacks, running it yourself): docs/reference/NEAR.md.
Related MCP server: memmd-mcp
From the InterSystems contest
An InterSystems IRIS production pays each step of lab work only when its test passed: an AI Hub agent reads the result, a rule decides, and above $50 a person approves.
The online demo is offline during voting. It ran in a GitHub codespace, whose free hours ran out on 14 Nov at about 21:20 UTC. Watch the video, or run Knos with one command on your machine (below).
Video: 43 s, a narrated live run on 13 Nov 2026 from the online demo, downloadable with no login: knos-iris.mp4.
Community idea: it implements DPI-I-689, each decision step an interoperability message.
Judge it in 2 minutes: with the video, no login and no key.
Judge it in 2 minutes on IRIS
The online demo is offline during voting, so these steps use the video; the next section runs it on your machine.
Open knos-iris.mp4 (43 s) - see the production running in the IRIS portal and one sample decided by the AI Hub agent on NEAR AI Cloud.
Watch on - see that decision's trace, then the same session in Visual Trace.
Run it on your machine (about 6 minutes)
You need Docker with about 4 GB free; the first build takes about 4 minutes, as in CI. This one-command edition is the public IRIS for Health Community image (2026.2), which has no AI Hub: its samples replay the AI Hub agent's answers recorded in the online demo, and the rules referee decides anything else.
Run:
git clone https://github.com/drexthealpha/Knos && cd Knos/iris docker compose -f docker-compose.public.yml up -d --build && bash scripts/ready.shsee
READY: open http://localhost:52773/knos/ and press a sample button. CI runs it from a fresh checkout.
Open http://localhost:52773/knos/ and press A passing test, $20 - see it marked paid: "Paid in play money".
Open http://localhost:52773/csp/sys/UtilHome.csp, sign in as
_SYSTEMwithknos-public-demo, then Interoperability > Production - seeKnos.Iris.Productionand each decision's Visual Trace.
The contest entry: build 154 with AI Hub. With the image file from the
AI Hub Early Access portal (an InterSystems login):
bash scripts/load-image.sh <the tar>, bash scripts/env-secrets.sh && docker compose up -d --build, then
bash scripts/ready.sh. There the AI Hub agent can decide on a model.
The live run of 12 Nov, the contest task part by part, the bonuses and troubleshooting: docs/reference/IRIS.md.
Why a payout step in a lab workflow. A lab funds outside work in steps, so the last step of the decision is to pay the one whose test passed. In replay mode PAY runs a devnet simulation of that payout: it proves the gate reached PAY and the payout path ran end to end, and no money moves.
Why I built this. A solo founder, building Knos since 1 Sep 2026. IRIS and its Docker build would not fit on an 8 GB laptop, so every IRIS build and test moved to one GitHub Codespace (the problems I hit).
From Colosseum
The Colosseum entry is tag v0.3.28 (built 14 Sep to 12 Oct 2026): it pays AI coding agents only when your own checks pass.
In that entry you posted a task, a price and your tests on a GitHub issue; the money waited in a Solana program, and when the pull request was merged the program checked GitHub's signature on the checks before it paid. Solana devnet, test USDC.
Judge it in 2 minutes
Open https://drexthealpha.github.io/Knos/check/ - see "The ten-second check" and "Built 14 Sep to 12 Oct 2026 for Colosseum (tag v0.3.28)".
Paste
https://github.com/drexthealpha/knos-playground/pull/35into Pull request and press Check - see "Claims nothing about tests; every check passed."Press the link "4PovnMjD...2zcDxt" on that page - see a payment of 0.25 test units on Solana devnet, 2 Oct 2026, by program 9UzPF...AdfDi, which the explorer lists as "Unknown Program": the first deployment of Knos's payment program.
The code as entered: https://github.com/drexthealpha/Knos/tree/v0.3.28. More: docs/reference/COLOSSEUM.md.
Use Knos where you already are
Add Knos to a chat or coding assistant that takes connectors, with one command:
claude mcp add --transport http knos https://knos.onrender.com/mcpIt gives two tools: tools lists what Knos can do, and run runs one. A worked example, the front door's sample battery test checked against its limit without the connector:
curl -s https://raw.githubusercontent.com/drexthealpha/Knos/main/near/agents/job/data/limit/sample.csv | jq -Rs '{id: "limit-check", table: ., column: "capacity_ah", rule: "above", limit: 1.4}' | curl -s -X POST https://knos.onrender.com/api/run -H "Content-Type: application/json" -d @-The answer's result is Failed at row 136: 1.399 is not above 1.4. 135 rows passed. Its link opens the result. Through the connector, run with the same id, table, column, rule and limit returns the same answer.
More
Why Knos exists. The full reference: docs/reference/NEAR.md, docs/reference/IRIS.md and docs/reference/COLOSSEUM.md. MIT licence. Built by drexthealpha, a solo founder.
Available Tools
3 toolsaboutAInspect
What is known about one thing: a file, a person, a topic.
Inputs: thing (required). Returns: result
rememberAInspect
Write something back, so the next session in any agent knows it too.
Set `claiming` when you are about to start work on this, rather than
just noting something. Other agents are then told you have it and knos
withholds it from them until you finish or half an hour passes. Writing
a plain fact claims nothing: a note everybody can read is the point.Inputs: fact (required), about (required), claiming. Returns: result
searchAInspect
Search this machine's memory of the repo: past agent sessions, commits and code structure. Every result names where it came from.
Work another agent has claimed is withheld: you get who holds it, not
the answer. Ask them, or pick up something else. If you genuinely must
have it, call again with `override` set to your reason, which is
recorded in the journal against your name.
`on_behalf_of` names a teammate when the agent is working for one. They
see only the folders they were actually shared, and nothing else.Inputs: query (required), limit, override, on_behalf_of. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
search and about both query stored knowledge, so an agent could initially confuse a broad search with an entity-focused lookup, but the descriptions make the distinction clear: search returns provenance-backed results from repo memory, while about targets one thing. remember is wholly separate as a write operation.
All tool names are lowercase single words, creating a simple and consistent style; search and remember are clear verbs, while about is more of a query noun/preposition, slightly deviating from a strict verb pattern.
Three tools is well-scoped for a focused memory/knowledge server: query broadly, query a single entity, and write back. Each tool has a distinct role and none feel redundant or missing at this level of abstraction.
The core read/write/query lifecycle for shared repo memory is covered, and claimed work handling is integrated into search and remember. Minor gaps exist around updating or forgetting explicit memories, but agents can work around these with search.
Maintenance
Related MCP Connectors
One memory for your AI agents and your team: Claude, ChatGPT, Cursor and your agents share it.
Shared memory for coding agents. Stop re-explaining your codebase every session.
One shared brain for your AI coding agents: team memory, agent Q&A, tasks, and file claims.
One memory for you and your AI agents, shared by ChatGPT, Claude, Gemini, Grok, Codex and Cursor.
Related MCP Servers
- AlicenseAqualityDmaintenancePersistent shared memory for AI coding agents. Stores facts as entity/key/value triples with hybrid semantic search, task checkpoints, and conflict resolution — shared across Claude Code, Codex CLI, and GitHub Copilot.16235 npm5AGPL 3.0
- AlicenseBqualityDmaintenanceA shared memory layer for AI agents — one memory.md synced across Claude Desktop, Cursor, Claude Code, OpenAI Codex, and any MCP client.42MIT
- FlicenseNot gradedqualityCmaintenanceLocal-first cross-agent memory for AI coding agents. Persistent, shared memory over MCP — what you tell one agent can be recalled by another — with all data stored in a single local SQLite file, no cloud and no API keys.-
- AlicenseNot gradedqualityBmaintenanceLocal-first memory for your AI agent. One SQLite file you own — offline, no API key. Plugs straight into Claude Code.Apache 2.0