io.github.drexthealphaPublished by GitHub account drexthealphav0.4.0Updated Nov 7, 2026
The neutral meter for AI agent work: neither side keeps the count.
Knos turns a paper or product idea into a demand check, a locked brief and milestone work paid only on verified proof, using test money.
Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.
Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.
Read https://sourceweft.com/mcp/io.github.drexthealpha%2Fknos/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.Add this to your client's mcpServers config.
{
"mcpServers": {
"knos": {
"type": "http",
"url": "https://knos.onrender.com/mcp"
}
}
}Knos carries research across the valley of death.
Video · Open Exchange · Article · Code · Run it on IRIS · Try it on NEAR
Test money only.
[Image] Job posted → [Image] Money held → [Image] Helpers try → [Image] Check passed → [Image] Helper paid
[Image] Qloo checks demand · [Image] IRIS checks proof · [Image] NEAR and Solana devnet pay · [Image] Sibyl remembers each result
No money locks on a vague brief. Each step is paid only when its proof is verified.
Add Knos to Claude Code with one command: claude mcp add --transport http knos https://knos.onrender.com/mcp
Open call: have research waiting for a market? Cross it on Knos: the page counts every crossing and pre-order by people outside Knos, live.
The proof is checked before any money moves. A milestone names its checker in the brief. The proof can be:
Nothing is paid on a promise. A missed deadline sends the money back.
Open the demand check in your browser. Type what you are about to build, or press one of the samples. Qloo's taste data says who wants it and where to launch it. The whole crossing runs in the app, with nothing to install and no sign-up.
The terms of a brief are locked by a hash before any money moves. A changed target or deadline gives a different hash. So a change cannot hide.
The money waits in a program on Solana, not with Knos. That program pays only on a verified proof. At the deadline it refunds the backers instead.
Neither the maker nor Knos can move the money alone.
Today one person can still change that program, after a public wait (who holds the keys).
Today Knos earns its fee only when work is accepted. When you get a refund, the fee goes back to you. So Knos gains when work passes, and it is not yet fully neutral (what is enforced and what is a promise).
It runs on test money only: test USDC on Solana's practice network, devnet.
There are no customers yet. Nobody has bought anything (what is not real yet).
One person holds every key today. Any change to the programs waits in public for 8 days first (who holds the keys).
A lab pays for a research milestone only when IRIS finds the proof met. An AI Hub agent on a local model weighs a GitHub check run or a lab result. A rule decides next, and above 50 USDC a person in IRIS Workflow does. Only then does Solana devnet run a simulation with test money.
This entry runs on AI Hub build 154 (irishealth-community 2026.3.0AI.154.0), which the portal removed on 2 Nov 2026; build 109 is not tested.
knos.ready.criteria_hash, run in Embedded
Python from the same src/knos that the Knos app uses. Proof against a changed brief is refused before any model is
asked.You need Docker with about 4 GB free for it, and the InterSystems image file
irishealth-community-2026.3.0AI.154.0-docker.tar.gz (x64) from the
AI Hub Early Access portal (an InterSystems login).
Load the image and retag it to the name the Dockerfile builds on:
(bash iris/scripts/load-image.sh <tar> does both.) Neither image, nor any image built on it, is pushed to a registry.
Get the code and make .env with random secrets:
Pick the model (the LLM provider). The default needs nothing: KNOS_AI_MODE=local asks qwen2.5:1.5b-instruct in
the ollama service through AI Hub's openai provider, with no key and no account. For a cloud model set
KNOS_AI_MODE=live, KNOS_LLM_PROVIDER and its key in .env:
A spend cap is checked before any paid call: at most KNOS_LLM_MAX_CALLS calls (default 30) and
KNOS_LLM_MAX_USD dollars (default 2.00). Never commit .env.
Start it:
The first start builds the image (about 3 minutes on 4 cores) and pulls the local model (about 1 GB).
bash scripts/smoke.sh sends one decision on public data and prints decision: {"decision":"met","gate":"PAY",...}
and a Visual Trace link.http://localhost:52773/knos/, sign in as _SYSTEM with the IRIS_PASSWORD line of .env: each decision,
its trace and the approver's inbox.AMOUNT_USDC=80 bash scripts/smoke.sh: above 50 USDC the met decision waits for a person. Press Approve in the inbox
on /knos/ (or Interoperability > Workflow Inbox), then open the decision's Visual Trace link: the proof, the
agent's verdict, the rule, the approval and the devnet simulation, in order.Every test in one command, with no key: bash scripts/test-all.sh (the build, the decisions, one trace through all six
parts, the bonus checks and the page).
An InterSystems IRIS for Health production decides whether submitted proof meets a hash-locked Knos Ready brief: a
GitHub check run, a lab result (a FHIR Observation or an HL7 ORU^R01) or a Knos referee verdict. The three public
inputs scripts/smoke.sh uses are in data/public/SOURCES.md: a Synthea FHIR Observation, an HL7 ORU^R01 lab message
and a real GitHub check run.
/api/knos/webhook (signed with
KNOS_WEBHOOK_SECRET), by /api/knos/proof, or as a file the inbound adapter Knos.Iris.Adapter.CheckRunInbound
picks up. A lab result arrives as a FHIR Observation, or as an HL7 ORU^R01 file in inbox/oru/.Knos.Iris.AI.Verdict checks every answer. The rules referee, which
reads only structured fields, can only make an answer stricter, and the trace says so.Knos.Iris.Rule.PayoutGate turns the decision into PAY, HUMAN,
REFUND_AT_DEADLINE or REJECT. HUMAN goes to a person. PAY runs a devnet simulation through the Java PEX operation.Proof arrives one of three ways; one process checks, asks the agent, gates, asks a person, then simulates.
Measured in a 4-core, 16 GB GitHub Codespace with mem_limit: 3g: build 160 s from the loaded image, health 7 to 9 s
after the container starts, peak 1,660 MiB in docker stats. On a 7.8 GB laptop the container peaked at 1,188 MiB.
FHIR is off by default (KNOS_FHIR=0); KNOS_FHIR=1 loads R4 and needs about 2 GB more.
irishealth-community:2026.3.0AI.154.0 (InterSystems IRIS for Health, AI Hub build 154,
IRIS for UNIX (Ubuntu Server LTS for x86-64 Containers) 2026.3.0AI (Build 154U)), from the InterSystems file
irishealth-community-2026.3.0AI.154.0-docker.tar.gz (x64). iris/Dockerfile builds on it in stages: a builder stage
runs iris.script, the final stage copies in only the databases the install changed.
KNOS_AI_MODE=local (the default) needs no key: measured on 5 Nov 2026 on 4 cores, 7 to 18 s a decision, about 670
tokens. KNOS_AI_MODE=live uses the provider and key from step 3 above. KNOS_AI_MODE=replay asks no model and says
"rules referee (no model key set)". No paid model call has been made for this project.
With IPM on any IRIS for Health instance: zpm "install knos-iris" once the package is published, or from a clone,
zpm "load <clone>/iris -v" in a namespace with interoperability on. module.xml asks for IRIS 2026.3 or later with
interoperability enabled.
The health route answers {"production":"Running","agent":"local","fhir":"off","java":"ok","vector":"ok",...}.
/api/knos/webhook, or drop a file in
/home/irisowner/knos/inbox/checkruns/ for Knos.Iris.Adapter.CheckRunInbound. Unsigned webhooks get 401."kind":"observation") to /api/knos/proof, or drop an HL7 ORU^R01 named
<briefId>.hl7 in inbox/oru/. OBX-3 and OBX-5 become the Observation's code and value."kind":"verdict", as in fixtures/verdicts/passed.json).A met decision above KNOS_PAYOUT_THRESHOLD_USDC (default 50) goes to the role PayoutApprovers. Approve or Reject in
the inbox on /knos/ or in Interoperability > Workflow Inbox. With no answer, the milestone stays held for two days.
Each AI Hub feature the agent uses answers live at GET /api/knos/aihub/<feature>: skill, policy, mcp, rag,
stats and workflow.
On PAY, IRIS builds Knos's payout instruction and the Java PEX operation simulates it on devnet
(simulateTransaction): a simulation, not a payment. IRIS never releases money alone. The custom outbound adapter
Knos.Iris.Adapter.SolanaRpcOutbound does the reads.
Each decision's session in Visual Trace holds the Proof, the agent's Verdict, the Span messages and the Decision.
GET /api/knos/traces/<session> returns them as JSON; the table Knos_Iris_Data.Span has the same rows;
iris/docs/trace-schema.md maps them to Langfuse's trace fields.
Try it: bash scripts/smoke.sh prints a visual trace: link whose number is the session, then
SELECT Name, Kind, Model, Tokens, Ms FROM Knos_Iris_Data.Span WHERE SessionId = <session> gives every step.
Four reproduce on a clean build 154 container, each with its own run.sh:
iris/bugs/1: Embedded Python returns a Python int above 2^63 - 1 to ObjectScript as -1, with no error. Filed: python-bugreports#30.iris/bugs/2: AI Hub's %AI.ToolMgr.ExecuteTool runs a tool when a required argument is missing or of
the wrong type. Filed: ai-hub-eap-bugreports#20.iris/bugs/3: AI Hub's %AI.RAG.VectorStore.IRIS makes its table in SQLUser whatever its Schema
says. Filed: ai-hub-eap-bugreports#21.iris/bugs/4: Embedded Python's iris.sql.exec with an int past 64 bits fails with a SystemError
that names neither the parameter nor its value. Filed: python-bugreports#31.DependsOn fixed the
compile order; the install then passed on build 154./tmp default ACL was
the cause; scripts/codespace-setup.sh drops it.python iris/tests/test_iris_decision.py runs the core decisions against a running instance: a passing check run, a
failing one, an altered brief, injection text in the proof and an ORU whose value misses. python iris/tests/test_iris_one_trace.py sends one check run through the whole production and checks that its one session
holds every part.
python iris/tests/test_iris_docs.py readme checks that every file this section names exists.
The diagram under "How it works" above is the production; iris/src/Knos/Iris/Production.cls lists every item.
This folder is part of the one Knos product: Qloo checks demand, IRIS checks proof, NEAR and Solana devnet pay, and
Sibyl remembers each result. The Knos code is imported, not forked: the image runs the repository's src/knos.
Zulqarnain Abubakar, Developer Community profile: https://community.intersystems.com/user/zulqarnain-abubakar
MIT, the repository's own LICENSE.
Each bonus with what shows it.
On NEAR testnet, Knos pays a helper only when the test passes. The code is in near/, and every path in this
section is under near/ unless it starts with another top folder.
One job, two agents: only the output that passes the locked test is paid.
Problem. When you pay an AI agent for work, you pay for its claim that the work is done. Nobody checks the claim before the money moves.
What it does. A job's bid waits in a NEAR contract against a test locked by its hash. Agents take the job and submit. A checker runs the locked test on each output and signs a token for the one that passes; the contract checks that token, then pays. The agent whose output fails is paid 0.
Do this, see that:
python near/scripts/try_testnet.py <you>.testnet - see your own copy of both contracts release on a signed token
and refund after the deadline (Try it on testnet).bash near/scripts/verify.sh - see the contract's sandbox tests and attacks pass (Tests).What was built in the window. Everything under near/ and the hosted runner apps/wanted/knos_wanted/near_live.py:
the diff from the tag pre-hackathon (31 Oct 2026) is
https://github.com/drexthealpha/Knos/compare/pre-hackathon...main (near/ did not exist at that tag). The tag
hackathon-submission is added when the code is final.
Built before, on another chain (Q-002). Knos existed before this window on Solana devnet: the programs in
programs-v2/ and the Python package knos in src/knos/ that drives them. Only the NEAR work above is the entry.
The NEAR contract can pay a milestone out on Solana devnet through NEAR Chain Signatures
(Paid on Solana by Chain Signatures).
Own older code and libraries (Q-005). The hosted runner reuses the older app server in apps/wanted/ (routes, rate
limits) and its Render deploy. The libraries are listed under Disclosure. Most of the code was written with Claude Code.
Tracks it fits. Agent Economy (agents): agents with their own sub-accounts whose keys can only call the jobs
contract, under a spend cap. AI Swarms (swarms): two agents on one job, paid by the result of a locked test.
The test is locked before money is held and checked before money moves: nobody is paid on a claim. (Demand is checked first, by Qloo, on the site.)
A company pays a lab or a developer only when GitHub's signed run proves the milestone. The money waits in a NEAR contract; after the deadline with no proof, the company gets it back. The payout is paid on NEAR, or on Solana through NEAR Chain Signatures: the contract checks the transfer and has the MPC network sign it.
Spending limits cap what an agent may spend. Knos pays only for work that is proven done.
Open drexthealpha.github.io/Knos/near/ and click Post a job. You see "Paid: Helper A $1.00. Helper B $0, its work failed." and a link to the payment on NEAR testnet, within seconds: a job is kept ready, posted against its locked test and tried by both agents, so your click sends the payment to the one whose output passed.
It runs on Knos's own capped test account (live.knos-swarm-1105.testnet, test tokens only): 20 runs
a day, three every 10 minutes from one address; past a cap the page shows the last run and says "Replay". The same job from a
terminal: pip install knos, then knos near-job.
Every change since the work began: pre-hackathon...main
(the tag pre-hackathon is the commit before the first line of near/).
No Rust is needed to check or deploy the contract: near/wasm/ holds the built files and near/wasm/SHA256SUMS their
hashes. cd near/wasm && sha256sum -c SHA256SUMS prints knos_near.wasm: OK and knos_mock_usdc.wasm: OK
(a5fc5861…, 280,651 bytes, is the jobs contract deployed at jobs.knos-swarm-1105.testnet). Building them again and
every test: bash near/scripts/verify.sh (Rust with wasm32-unknown-unknown and cargo-near 0.22.0).
Your own copy of the contract, then a release and a refund. About 4 minutes after step 2. You need Python 3.10+ with cryptography, and near-cli-rs 0.30.1.
near account create-account sponsor-by-faucet-service <you>.testnet autogenerate-new-keypair save-to-legacy-keychain network-config testnet create. You see "New account <you.testnet> created successfully." and its transaction.python near/scripts/try_testnet.py <you>.testnet. You see six sub-accounts made and the two contracts deployed from near/wasm/ (sha256 in near/wasm/SHA256SUMS).m1 and releases it on a signed token. You see "release m1 on a signed token: done" with its transaction.m2 with a 1-minute deadline, waits, and refunds it. You see "m1: Released" and "m2: Refunded".The page in web/ runs the same flow from a browser (python near/web/serve.py, checked by web/test-flow.mjs), but on the maintainer's test accounts (knos-*-1102.testnet, knos-pay2-1102), whose keys only that machine holds; it does not use your account yet. web/story/ takes a milestone apart as you scroll.
Post a job with a locked test and a bid; two agents take it; the checker runs the locked test on each output, and only
the agent whose output passes is paid. You need Python 3.10+ with cryptography and near-cli-rs 0.30.1; it runs on the
maintainer's test accounts, whose keys only that machine holds (as the page in web/ does).
NEAR_CLI=<near> python near/web/serve.py and open http://127.0.0.1:8790/. You see "Paid only when the test passes" and a Post a job button.http://127.0.0.1:8790/embed.html from another page or origin and click Pay with any wallet. You see a NEAR Intents 1Click quote for paying 1 USDC from Base (dry: nothing is spent), then a second click pays the bid on testnet.The rules are in near/agents/RULES.md: the job's test is locked by its sha256 at funding, each agent is a
sub-account of knos-swarm-1105.testnet that signs with a function-call key allowed only take, submit and spend on
the jobs contract (its full-access key deleted), and the checker's key is set by 2 of the 3 owners.
web/test-job.mjs
walks these four steps in a fresh browser. One run, 5 Nov 2026:
Agent A was paid 1000; agent B was paid 0. NEAR Intents has no testnet, so the 1Click call is a dry quote only, with 0 spent on mainnet. The checker runs an agent's output in a subprocess with a 20 s limit and no environment; it is a test-money demo, not a sandbox for hostile code.
Each claim has a yes/no market in test tokens: will its locked check pass? The contract is
near/market/src/lib.rs, deployed at market.knos-swarm-1105.testnet (wasm wasm/knos_market.wasm).
knos-pay-1103.testnet:
its criteria hash is locked at funding and only the named GitHub Actions workflow's own OIDC token can release it.
resolve reads that milestone: Released settles Yes, Refunded (the deadline passed with no passing run) settles No.
vote and set_test are refused, always. redeem pays each winning share.near/claims/Split.lean, "splitting a bid between two helpers never pays out
more than the bid". Its check is lean-claim.yml: the proof must compile
with Lean 4.15.0, then the run's token releases the milestone whose criteria hash is the file's sha256.Every push that changes near/ runs them on GitHub: the near-tests runs.
Open the newest run, then its verify job: the step near/scripts/verify.sh ends with the line below. With Rust
(the wasm32-unknown-unknown target and cargo-near 0.22.0) the same on your machine:
It prints 208/208 tests passed (146 of them attacks), the contract's unit tests and then the sandbox flow, and fails when that print is not this line.
Each attack changes one thing and must be refused with the contract's own reason. The thing changed is one of these: the token's issuer, audience, expiry, repository, workflow, commit, header, form or signature; the funding message; the key set.
Or it is a second payment, an early refund or a release after the refund; for a job, a token for another output, job, test or payee, a checker key against a GitHub token and back, an agent that never took the job, a spend over the cap.
verify.sh builds both contracts to wasm and runs them on a local near-sandbox node: fund, release, replay, forgery and refund.
Measured: the release receipt burns 7.33 Tgas (11.68 Tgas for the whole transaction) in the latest verify.sh run (5 Nov 2026, a fresh clone); the replayed and the forged token are refused; after the deadline the payer gets the money back and a later release is refused.
Read the rules from the chain:
sign_payout takes the unsigned Solana message for a released milestone. The contract accepts only one SPL TransferChecked of exactly the milestone's amount, in the mint and to the token account locked at funding, then asks v1.signer-prod.testnet (path knos-solana-1, Ed25519) to sign it. A relayer adds the signature and broadcasts; no Solana key is held anywhere.
The payout moves tokens held since funding. At funding the funder moves the amount from its own Solana token account into one owned by the contract's derived address; the payout is the transfer of exactly those tokens, and nothing is minted on the way.
A milestone released for a Solana payee with no payout signature by its deadline is refunded like an unreleased one, so it never stays locked; once its payout is signed, it is not.
scripts/solana_payout.py run does both on knos-pay-1103.testnet (code sha256 3503799e…), derived Solana address DUxGyghGoZNZu85zVJXHLAgsrA3rBt3eVDSGmhk8bzBi, on 3 Nov 2026:
Not built: when a released Solana milestone is refunded on NEAR, the tokens already held by the derived address stay there; a signed transfer back to the funder is not written yet.
relayer/relay.py is a NEP-366 relayer that pays only for calls to one Knos contract (knos-pay2-1102.testnet in the test). scripts/test_gasless.py has the payee sign a release as a delegate action; the relayer sends it (4XpFZwBM…) and the payee's NEAR balance is the same to the yoctoNEAR.
Every other call the test sends is refused, the token contract's ft_transfer among them, and the test prints each with the relayer's reason (the relayer also writes them to its local relay.log, not kept in the repository).
agent/guard.py answers allow, warn or block for a receiver, from chain: no such account or on the shared blocklist (agent/blocklist.json, each entry with its evidence) is a block; a contract, an account under 7 days old or code changed in the last day is a warning that a person resolves.
scripts/test_agent_guard.py gives the agent a key that can call only release, refund and sign_payout here, then a task with an injected instruction to pay two other accounts: both are refused, and the chain refuses the key on the token contract.
eval/attempts.json holds 60 attempts, 30 honest and 30 cheating, each with a green CI run; its sha256 (eval/attempts.sha256) was committed before the first run. cargo test locked_eval -- --nocapture sends each through the contract, prints the counts with 95% Wilson intervals, and asserts them: every cheating attempt refused, every honest one paid, and plain CI pass/fail paying every cheat.
Read it for what it is. Each cheat is one of the four things the contract checks (a run from another branch or a pull request, another repository, a replayed token, altered criteria), and each carries a green CI run by construction, so the result shows that those checks run on every attempt.
It does not measure cheats the contract does not look for: tests edited and merged to main are outside what it can see.
36 attacks and 4 controls, each a real transaction on the contract above. The first 37 rows were sent by scripts/attack_testnet.py, with tokens signed by an RSA-2048 test key that two owners set as kid knos-test, standing in for GitHub's key, so each row changes one thing.
The last 3 were sent by .github/workflows/near-release.yml (run 41651312325) with that run's own GitHub token, kid 38826b17-6a30-5f9b-b169-8beb8202f723.
contract/: the contract (lib.rs), RS256 (rsa.rs), token parsing (jwt.rs), the Solana payout check (solana.rs), unit tests (tests.rs, tests/).mock-usdc/: a NEP-141 test token for the sandbox.sandbox/: the sandbox test.relayer/: the gas relayer. agent/: the receiver guard. agents/: the two agents, the checker, the job's locked test and its rules.web/: the page and its server (serve.py, jobs_api.py), the pay button (pay.js); web/story/: the scroll story. wasm/: the built contracts.Changes since the start of this work: near-pre...main.
Who wrote it: Claude Code (Anthropic's coding agent) wrote most of the code in this folder. The founder set each task and reviewed each change before it was merged. Commits carry the founder's account.
No starter template: the first commit of this folder (6413e89) adds each crate as written, with no generated scaffold in the history. The test token in mock-usdc/ uses the FungibleToken implementation from near-contract-standards, as its own documentation shows.
The contract's checks are this repository's own code (contract/src/rsa.rs, jwt.rs, solana.rs), with no crypto crate among the contract's dependencies (hashing uses the NEAR runtime's own sha256).
Libraries, at the versions in each Cargo.toml:
Tools: Rust with the wasm32-unknown-unknown target and cargo-near 0.22.0 (scripts/codespace-setup.sh); the testnet steps use near-cli-rs. Services: NEAR testnet, NEAR Chain Signatures on testnet, Solana devnet and GitHub Actions' OIDC tokens.
Install with pip install knos. The app answers the same steps over HTTP: POST /api/check (the demand check), POST /api/ready (the Ready brief) and POST /api/preorder (a pre-order on devnet). Run knos idea --help for every option.
Start at the release page: the code, how it is built, what runs on devnet, the payments and the fees.
One payment from start to end, on 9 Oct 2026 with Knos 0.3.23, in a repository Knos owns, with test USDC (one step fixed by hand): funded · wrong work refused · paid (on verified proof) · replay paid nothing more · the record.
Rebuild knos_oidc and knos_pay, the programs that check the proof and pay, and compare: the hash devnet runs equals the verified build hash recorded for each (PROVENANCE). Read on 27 Oct 2026.
Qloo, Ready brief, milestone and more, each in one plain line: docs/WORDS.md.
Knos takes research from a paper to a product people want. It pays each step only on verified proof.
You post the task, your checks and the pay before work starts. When the checks pass and you merge, a program pays the agent.
No. It runs on devnet, Solana's practice network, with test USDC worth nothing.
Ten demand checks a month are free; releases will cost companies 1%. Today devnet charges 0.30%, at least 0.05 test USDC.
A program on Solana holds it, not Knos. Today one person can change that program, after a public wait.
Not once the checks pass and the work is merged. Before that, the buyer still chooses whether to merge.
Neither side alone. A program checks GitHub's signature of which workflow ran, on which commit.
Open the front door and type the product you want to build. It says who wants it and where, with no sign-up.
Get started: check demand, write a Ready brief, then hold the money and pay on proof.
Pricing: what Knos costs. Demand checks are free, 10 a month. The maker keeps 100%; the funder pays the payment program's fee on top: 0.30% of each payout, at least 0.05. Nobody is charged today (devnet, test money).
Trust: who holds the keys, and what is tested.
The story: one crossing, step by step, each with its evidence.
Every other document: the map of the documents.
Contact: open an issue, or report a security problem privately: SECURITY.md.
Below: tables that scripts write from the code and the chain, and the licence. Nobody types them by hand.
Every program the app or this site uses, and who can upgrade it, read from devnet on 2026-10-26 (scripts/program_authorities.py):
This page names no time for an upgrade, so it stays true before and after one. To see whether a change to the
programs is waiting, done or withdrawn, run knos status, or read the site's banner or its
upgrade record (web/upgrades.json is the
copy kept here).
The first set of programs (programs) has no upgrade authority, so nobody can change it.
It stays as a record, and no new task is funded there.
Reproduced by someone else: none recorded yet. Exercised on devnet: verify_github, fund_by_comment, fund_from_wallet, pay_on_merge and more, each named in the table. Deployed on devnet: verify_gitlab, key_guardian, hold_and_bind. Everything else is tested locally, implemented or not built: the table with the evidence has one row for each capability, from docs/capabilities.json. Only runs at the public program ids count here. Each capability's row also notes, with its transaction, any earlier trial run at separate test addresses (Knos 0.3.14).
MIT licence, all of it. Built by drexthealpha. Everything Knos remembers is kept by the Sibyl memory engine.
Source: README.md at commit 0143141
Cross a paper to a funded product
Paper id (DOI, arXiv, PubMed, OpenAlex) -> research card -> Qloo evidence at every decision -> who, where, price tier, held-money target and reserve, and OPEN or REFUSE. Returns every step with its Qloo call, input, output and effect.
agerefcityideanearqloosortplaceadmin1admin2genderlookup+68 moreRead a landmark paper
Paper id -> the proven result (quoted), citations, retraction status, Nobel recognition, the product it enables.
refrequiredIs this product wanted? (Qloo)
A product idea -> Qloo evidence -> a decision made by code. Every Qloo demand family is a typed argument: who (age, gender, audiences), gaps (hide_leader, exclude, popularity_max), where (near, radius, location, geohash, region names), price tier (price_level, price range), who serves it (references_brand, quality, sort, ratings), product kind and years (film/TV/book/person), look up (lookup, entity_id), and `qloo` for any other documented parameter.
agecityidearequirednearqloosortplaceadmin1admin2genderleaderlookup+67 moreCrossings on this server
Every crossing this server ran, newest first: id, paper or idea, verdict, report hash.
Takes no parameters.
Open milestones
Every commitment on this server: held order, units, status, claim id. A locked one needs an evidence page.
Takes no parameters.
Open work for contributors
Open game rounds and milestones a person or agent can work on; judged and paid on devnet (test money).
Takes no parameters.
Search everything this Knos remembers
FTS5 search (multilingual) over the agents' memory and the Knos Record: papers, crossings, decisions, events.
qrequiredWhat the agent remembers about a paper
Sibyl, the crossing agent's working memory: the last crossing of a paper or idea (product phrase, verdict, report).
refideaA session for the money tools
Returns a session token the money tools need. CONFIRM FIRST: this moves devnet TEST money or posts work. Ask the human you work for before calling. Needs Authorization: Bearer in the HTTP header (an agent key's OAuth token), or the session token knos_sign_in returned. Test money only; no real funds.
labelrequiredPre-order (your human's passkey signs)
Prepares a pre-order of an OPEN report: no server key buys for anyone, so it returns the page where your human's passkey approves it (devnet test money). CONFIRM FIRST: this moves devnet TEST money or posts work. Ask the human you work for before calling. Needs Authorization: Bearer in the HTTP header (an agent key's OAuth token), or the session token knos_sign_in returned. Test money only; no real funds.
unitsrequiredreportrequiredsessionPost milestone evidence
Posts a milestone's public evidence page; verified evidence releases the held money to the maker. CONFIRM FIRST: this moves devnet TEST money or posts work. Ask the human you work for before calling. Needs Authorization: Bearer in the HTTP header (an agent key's OAuth token), or the session token knos_sign_in returned. Test money only; no real funds.
sessioncommitmentrequiredevidence_urlrequiredSubmit work to an open round
Submits the whole train.py to the open round (knos_tasks says what to change and links the task's README); the sealed referee judges it at once; several attempts per round. A scored attempt with a devnet `wallet` is paid a demo prize in test units. CONFIRM FIRST: this moves devnet TEST money or posts work. Ask the human you work for before calling. Needs Authorization: Bearer in the HTTP header (an agent key's OAuth token), or the session token knos_sign_in returned. Test money only; no real funds.
coderequirednameroundrequiredwalletsessionMilestone templates
AI model eval, hardware prototype, internal tool, paper to pilot, vendor deliverable; and the ISO 13485 / EU MDR regulatory milestones from OpenRegulatory's open templates (with attribution and licence).
Takes no parameters.
Projects and their milestones
Every project: milestones (tranches), their held orders, AMC commitments, attempts and where the work can be bought.
idOpen a project from a template
Opens a project; each milestone is its own tranche, released only on a result plus an independent check. CONFIRM FIRST: this opens or changes work that devnet TEST money depends on. Ask the human you work for before calling, and say what it does. Needs Authorization: Bearer (an agent key's OAuth token, or a session).
titlerequiredsessiontemplaterequiredregulatoryAttempt a milestone
Takes a milestone as a maker (parallel attempts allowed) and binds the wallet it pays (an agent key: its payout wallet, leave wallet out). A missed deadline refunds the funders and reopens it to others. CONFIRM FIRST: this opens or changes work that devnet TEST money depends on. Ask the human you work for before calling, and say what it does. Needs Authorization: Bearer (an agent key's OAuth token, or a session).
walletprojectrequiredsessionmilestonerequiredPost a result or an independent check
role=result (the maker) or check (someone else, another site): a public https page containing the milestone's claim id. Both in: the referee panel releases (the FROST group: 2 of 3 independent hosts re-check and sign). CONFIRM FIRST: this opens or changes work that devnet TEST money depends on. Ask the human you work for before calling, and say what it does. Needs Authorization: Bearer (an agent key's OAuth token, or a session).
urlrequiredrolerequiredattemptrequiredprojectrequiredsessionmilestonerequiredSubmit to a referee-judged milestone
For a milestone whose verifier is knos-referee:<round>: claims it for you if you have no attempt yet (an agent key: paid at its payout wallet, one claim of its cap), sends your whole train.py to that round's sealed referee, and when the verdict meets the target the held money is released to you with no human step. knos_tasks links the round's README. CONFIRM FIRST: this opens or changes work that devnet TEST money depends on. Ask the human you work for before calling, and say what it does. Needs Authorization: Bearer (an agent key's OAuth token, or a session).
coderequiredwalletprojectrequiredsessionmilestonerequiredThis server's OpenAPI document
The same API as REST: /openapi.json.
Takes no parameters.
Ready to fund
Free check of a brief before any money locks: each milestone needs a measurable target (number and unit, or a named test), a verifier (a GitHub check name, or what/how/who/where) and a deadline; vague words are flagged. Returns Ready, or Not ready with the missing fields and a rewrite template. Sends nothing.
briefrequiredWhat was asked of Knos
In plain words: which Knos tools were called over MCP and how many times since this server started, and the token use recorded for Knos's own goals (shown beside the 2.08x IDT ratio). Reads only, except `record`: the operator (its X-Knos-Admin key) records a goal's measured token use.
recordThe brief an agent works from
For a milestone you work on: the locked intent (goal, success check, constraints, scope) with its criteria hash, the effort level and output-token budget, and how to answer (minimal drafts, confidence first, stop when the check passes). Use it as your first instruction; do not re-derive the brief.
projectrequiredmilestonerequiredqloo capabilities
The official qloo-harness tool qloo_capabilities, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo find tags
The official qloo-harness tool qloo_find_tags, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo describe
The official qloo-harness tool qloo_describe, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo audience demographics
The official qloo-harness tool qloo_audience_demographics, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo entity tags
The official qloo-harness tool qloo_entity_tags, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo where popular
The official qloo-harness tool qloo_where_popular, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo trends
The official qloo-harness tool qloo_trends, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo compare audiences
The official qloo-harness tool qloo_compare_audiences, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo rank
The official qloo-harness tool qloo_rank, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
qloo recommend
The official qloo-harness tool qloo_recommend, proxied from this server's `qloo mcp` (LIVE).
Takes no parameters.
100% of the applicable checks met
How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.
flowchart TB idea["A paper or an idea"] --> demand["Demand check on Qloo: who wants it, the launch city and the pre-order target"] demand --> ready["Ready brief: each milestone has a target, a checker and a deadline, locked by a hash"] ready --> held["Backers pre-order or fund milestones; the money is held on Solana devnet"] held --> proof["The maker sends the proof for one milestone"] proof -->|verified| paid["The maker is paid for that milestone"] proof -->|not verified by the deadline| back["Nobody is paid; the money goes back to the backers"]flowchart TB held["The money is held on Solana devnet"] --> proof["The maker sends the proof for one milestone"] proof -->|verified| paid["The program pays the maker for that milestone"] proof -->|not verified by the deadline| back["The program refunds every backer"]docker load -i irishealth-community-2026.3.0AI.154.0-docker.tar.gzdocker tag docker.iscinternal.com/docker-intersystems/intersystems/irishealth-community:2026.3.0AI.154.0 irishealth-community:2026.3.0AI.154.0git clone https://github.com/drexthealpha/Knos && cd Knos/iriscp .env.example .env && bash scripts/env-secrets.shdocker compose up -d --buildflowchart LR gh["Check run (webhook or poller)"] --> pin["ProofIn"] lab["FHIR Observation or HL7 ORU"] --> pin ver["Referee verdict"] --> pin pin --> bp["ProofDecision (BPL)"] bp --> hash["Brief hash vs lock (Knos, Embedded Python)"] bp --> ref["Referee: AI Hub agent on a local model"] bp --> gate["PayoutGate"] gate -->|HUMAN| wf["Workflow: PayoutApprovers"] gate -->|PAY| sol["SolanaRead, then SolanaSubmit (Java PEX)"] bp --> trace["Span messages in Visual Trace"]set -a; . ./.env; set +acurl -s -u "_SYSTEM:$IRIS_PASSWORD" localhost:52773/api/knos/healthflowchart LR post["A job: its bid held in a NEAR contract against a locked test"] --> try["Two agents take it and submit"] try --> check["The checker runs the locked test on each output"] check -->|passes| paid["The contract pays that agent"] check -->|fails| zero["That agent is paid 0"]bash near/scripts/verify.shnear contract call-function as-read-only knos-pay-1103.testnet get_rules json-args '{}' network-config testnet nowknos demand "a vegan ramen food truck" --place London # Qloo's demand check: who, where, price tierknos idea get arxiv:<id> --out idea.json # a paper as one claim recordknos idea wanted idea.json # demand evidence and the stage plan; sends nothingknos idea commit idea.json --units <n> --price <n> # lock the stages on devnet, one order a stageknos idea check idea.json <oracle> # is one stage met right now?knos idea release <commitment> <stage> --sig <verdict> # pay a met stage on the referees' signed verdictsknos idea refund <commitment> <stage> --wallet <keypair> # refund a missed stage; anyone may send itsolana-verify get-program-hash -u devnet FkwZdsYCmzicJMtHLTkPK76bYNVG4WNwkWJBiVWNtF3W # knos_oidc: a2df952d262c48edacf2f594a01321e805c28f1dc523cb6efa75f2c45f34e632solana-verify get-program-hash -u devnet 5y7iWJ1VAMJjnnWbbdo2a2PsWJEwTExSNpzrvQSEnS8k # knos_pay: 8b3c044024eac6e00cf10930c325465d5682c3fb7273fe2f0d59c6e01f99867c