kredisco 0.1.0__tar.gz

kredisco-0.1.0/PKG-INFO

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: kredisco
+Version: 0.1.0
+Summary: A trust layer for AI agents
+Author: Rahul Sah
+License-Expression: MIT
+Project-URL: Homepage, https://kredisco.com
+Project-URL: Source, https://github.com/kredisco/Kredisco
+Keywords: ai,agents,trust,reputation,llm,langgraph
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: cryptography>=41.0
+
+# Kredisco
+
+**A trust layer for AI agents.**
+
+Humans carry a credit score. It follows you between lenders, it is held
+by a bureau rather than by you, and it is built from what other parties
+report about your behaviour. A landlord who has never met you can decide
+whether to trust you in seconds.
+
+AI agents have no equivalent. You wire one into your pipeline and have
+no idea whether it is dependable until something breaks.
+
+Kredisco gives every agent a portable trust score, 300 to 850, earned
+from its real track record and held where the agent cannot reach it.
+
+---
+
+## Why agents need one
+
+A pipeline with six agents fails quietly. One step degrades, output
+quality drops, and you find out from a user complaint days later.
+Nothing tells you which agent to stop calling.
+
+The instinct is to ask the agents, or to collect ratings. Neither
+survives contact with incentives. An agent will always report that it
+did well. Open rating systems get farmed: an audit of ERC-8004's on-chain
+reputation registry found the large majority of reviewers exhibited
+coordinated Sybil behaviour, and after removing them most rated agents
+had no valid feedback left.
+
+Credit scoring solved this problem a long time ago, and not with better
+surveys. It solved it structurally: **the party being scored is never
+the party reporting.** Your bank reports your payments. You cannot file
+your own. You cannot edit the file. You cannot see the number until
+someone pulls it.
+
+Kredisco applies that structure to agents.
+
+## What the score is made of
+
+Like FICO, the score is a weighted blend of factors, and like FICO,
+every one of them comes from somewhere the scored party cannot reach.
+
+| Factor | Weight | Where it comes from |
+|---|---:|---|
+| Rework rate (inverted) | 0.45 | You retried, reassigned, or the next step errored |
+| On-time rate | 0.20 | Measured by the SDK wrapping the call |
+| Counterparty diversity | 0.20 | How many distinct organizations hired it |
+| History depth | 0.15 | Volume of recorded work |
+
+Scores run 300–850. A new agent scores 300, so abandoning a damaged
+identity means abandoning everything it earned.
+
+Rework carries the most weight because it is hardest to fake. An agent
+cannot retry itself, cannot stop a downstream step from failing, and
+cannot stop you from routing around it.
+
+## Who reports, and why it can't be gamed
+
+A lender reports your payment to the bureau. The bureau holds the file.
+A future lender queries the bureau, never you.
+
+Kredisco works the same way. Your orchestrator is the reporter, Kredisco
+is the bureau, and the agent is the subject:
+
+1. Your agent completes a task
+2. The agent signs a record of it; your orchestrator countersigns
+3. Your orchestrator submits it, authenticated with your API key
+4. Kredisco verifies both signatures and files it under your organization
+5. The score is recomputed from everything on file
+
+Both signatures are required, so neither side can act alone. An agent
+cannot manufacture a history, because every entry needs a real
+counterparty to have signed it. And it never holds its own score — when
+someone wants to know whether to trust it, they ask Kredisco.
+
+---
+
+## Quickstart
+
+### 1. Get a key
+
+Sign in with GitHub at the Kredisco dashboard and create an API key. One
+key covers everything you build.
+
+```bash
+export KREDISCO_API_KEY=kd_...
+```
+
+### 2. Install
+
+```bash
+pip install kredisco
+```
+
+### 3. Connect
+
+```python
+import os
+from kredisco import Kredisco
+
+kd = Kredisco(api_key=os.environ["KREDISCO_API_KEY"])
+```
+
+### 4. Name each agent you want scored
+
+An "agent" is any component you call and could imagine replacing: a
+model behind a prompt, a third-party API, a tool, a subprocess. Give it
+a name once. Kredisco creates its identity and reuses it forever after.
+
+```python
+extractor = kd.agent("invoice-extractor")
+reviewer  = kd.agent("code-reviewer")
+```
+
+### 5. Route your calls through `track`
+
+Take the call you already make:
+
+```python
+data = extract_invoice(pdf)
+```
+
+Hand the function to `track` instead of calling it yourself:
+
+```python
+data = kd.track(extractor, "extract", extract_invoice, pdf)
+```
+
+Four arguments: the agent, a label for the kind of work, **the function
+without parentheses**, then its arguments.
+
+Kredisco calls the function, times it, files a record, and hands back
+exactly what your function returned. If it raises, the failure is
+recorded and the exception propagates normally. Your logic does not
+change.
+
+That is the integration. Scores start appearing on the dashboard.
+
+---
+
+## Telling Kredisco what counts as a failure
+
+By default a task fails only if your function raises.
+
+Most pipelines have a stricter rule — a required field, a schema, a
+minimum length. Pass `validate` and Kredisco uses yours:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+)
+```
+
+**This matters more than it looks.** With no validator and nothing
+raising, every task passes, and the largest factor in the score is
+measuring nothing. Kredisco is worth most to pipelines that already
+check their own output.
+
+## Retries
+
+Add `retries=1` and a failed attempt runs again. Kredisco links the
+retry to the original task, and that link is what drives the rework
+factor:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+)
+```
+
+If your orchestrator already retries on its own, leave this off and use
+the context manager below for each attempt.
+
+## When everything fails
+
+If every attempt fails, `track` re-raises the last exception. Sometimes
+that is what you want. Often it is not — a graph node that stops the
+whole run because one step returned bad JSON is worse than a node that
+carries on with an empty value.
+
+Pass `default` and `track` returns it instead of raising:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+    default={},
+)
+```
+
+The failure is still recorded and the score still drops. Only your
+control flow changes.
+
+Without `default`, every call site needs its own `try`/`except`. With
+it, a pipeline step is one expression:
+
+```python
+def extract_node(state):
+    return {"fields": kd.track(
+        extractor, "extract", extract_invoice, state["pdf"],
+        validate=fields_ok, retries=1, default={},
+    )}
+```
+
+## When you cannot hand over a function
+
+Some code will not collapse into a single call — the body of a graph
+node, a streamed response consumed in pieces, a block with setup and
+teardown around it. Open a task and report the outcome yourself:
+
+```python
+with kd.task(reviewer, "review") as t:
+    findings = run_review(diff)
+    t.accepted = len(findings) > 0
+```
+
+The clock starts when the block opens and stops when it closes. An
+exception inside records a failure and re-raises.
+
+## Grouping by pipeline
+
+If you run more than one pipeline, tag each one. Same key, different
+label — they appear as separate groups on the dashboard but roll up to
+one organization.
+
+```python
+kd = Kredisco(
+    api_key=os.environ["KREDISCO_API_KEY"],
+    workflow_id="invoice-ingest",
+)
+```
+
+## Reading scores
+
+```python
+kd.score(extractor.pubkey)         # one number, 300–850
+kd.breakdown(extractor.pubkey)     # what the score is made of
+kd.dashboard()                     # your agents, grouped by pipeline
+kd.best("extract", minimum=650)    # highest scorer for a kind of work
+```
+
+`best` is the point of the whole thing: pick who does the work by track
+record instead of hardcoding a vendor and hoping.
+
+## Things worth knowing
+
+**Reporting never breaks your pipeline.** If Kredisco is unreachable or
+your key is rejected, the failure is logged and your work continues.
+
+```python
+import logging
+logging.getLogger("kredisco").setLevel(logging.INFO)
+```
+
+**Agent keys live on disk.** Kredisco writes each agent's keypair to
+`.kredisco/`. That directory *is* your agents' identity — lose it and
+every score resets to 300. Back it up, and add it to `.gitignore`.
+
+**Timestamps come from the SDK**, not from your agent, so an agent
+cannot shorten its own recorded duration.
+
+---
+
+---
+
+## A working example
+
+[`examples/langgraph_support_triage.py`](examples/langgraph_support_triage.py)
+is a four-agent LangGraph pipeline built on two different Claude models,
+with a validator on every step.
+
+Run it a few times. The scores separate for real reasons — one agent
+returns JSON wrapped in code fences, another hits a response shape the
+caller did not expect, a third is simply slower. Fix the prompt that is
+failing and watch that agent climb over subsequent runs, without ever
+catching the agent that never failed.
+
+That gap is the point. History has weight, and recovery takes work.
+
+---
+
+## What this does not solve
+
+**A dishonest reporter can fabricate everything.** Signatures prove who
+signed, not that the content is true. Credit bureaus have the same hole
+and handle it with licensing and liability rather than cryptography.
+Kredisco's mitigation is that keys are tied to GitHub accounts and the
+diversity factor requires many distinct organizations.
+
+**Identity is still cheap.** A bad score can be abandoned for a fresh
+keypair. Starting at the floor makes that costly, not impossible.
+
+**One score across all task types.** An agent good at summarising and
+bad at code review averages into noise.
+
+**Rate limiting is per-process** and does not survive horizontal
+scaling.
+
+**No test suite.** The scoring model has changed several times and was
+verified by inspection.
+
+---
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/reachrshah)
+[![GitHub](https://img.shields.io/badge/GitHub-14161A?style=for-the-badge&logo=github&logoColor=white)](https://github.com/idfwyy)

kredisco-0.1.0/README.md

@@ -0,0 +1,310 @@
+# Kredisco
+
+**A trust layer for AI agents.**
+
+Humans carry a credit score. It follows you between lenders, it is held
+by a bureau rather than by you, and it is built from what other parties
+report about your behaviour. A landlord who has never met you can decide
+whether to trust you in seconds.
+
+AI agents have no equivalent. You wire one into your pipeline and have
+no idea whether it is dependable until something breaks.
+
+Kredisco gives every agent a portable trust score, 300 to 850, earned
+from its real track record and held where the agent cannot reach it.
+
+---
+
+## Why agents need one
+
+A pipeline with six agents fails quietly. One step degrades, output
+quality drops, and you find out from a user complaint days later.
+Nothing tells you which agent to stop calling.
+
+The instinct is to ask the agents, or to collect ratings. Neither
+survives contact with incentives. An agent will always report that it
+did well. Open rating systems get farmed: an audit of ERC-8004's on-chain
+reputation registry found the large majority of reviewers exhibited
+coordinated Sybil behaviour, and after removing them most rated agents
+had no valid feedback left.
+
+Credit scoring solved this problem a long time ago, and not with better
+surveys. It solved it structurally: **the party being scored is never
+the party reporting.** Your bank reports your payments. You cannot file
+your own. You cannot edit the file. You cannot see the number until
+someone pulls it.
+
+Kredisco applies that structure to agents.
+
+## What the score is made of
+
+Like FICO, the score is a weighted blend of factors, and like FICO,
+every one of them comes from somewhere the scored party cannot reach.
+
+| Factor | Weight | Where it comes from |
+|---|---:|---|
+| Rework rate (inverted) | 0.45 | You retried, reassigned, or the next step errored |
+| On-time rate | 0.20 | Measured by the SDK wrapping the call |
+| Counterparty diversity | 0.20 | How many distinct organizations hired it |
+| History depth | 0.15 | Volume of recorded work |
+
+Scores run 300–850. A new agent scores 300, so abandoning a damaged
+identity means abandoning everything it earned.
+
+Rework carries the most weight because it is hardest to fake. An agent
+cannot retry itself, cannot stop a downstream step from failing, and
+cannot stop you from routing around it.
+
+## Who reports, and why it can't be gamed
+
+A lender reports your payment to the bureau. The bureau holds the file.
+A future lender queries the bureau, never you.
+
+Kredisco works the same way. Your orchestrator is the reporter, Kredisco
+is the bureau, and the agent is the subject:
+
+1. Your agent completes a task
+2. The agent signs a record of it; your orchestrator countersigns
+3. Your orchestrator submits it, authenticated with your API key
+4. Kredisco verifies both signatures and files it under your organization
+5. The score is recomputed from everything on file
+
+Both signatures are required, so neither side can act alone. An agent
+cannot manufacture a history, because every entry needs a real
+counterparty to have signed it. And it never holds its own score — when
+someone wants to know whether to trust it, they ask Kredisco.
+
+---
+
+## Quickstart
+
+### 1. Get a key
+
+Sign in with GitHub at the Kredisco dashboard and create an API key. One
+key covers everything you build.
+
+```bash
+export KREDISCO_API_KEY=kd_...
+```
+
+### 2. Install
+
+```bash
+pip install kredisco
+```
+
+### 3. Connect
+
+```python
+import os
+from kredisco import Kredisco
+
+kd = Kredisco(api_key=os.environ["KREDISCO_API_KEY"])
+```
+
+### 4. Name each agent you want scored
+
+An "agent" is any component you call and could imagine replacing: a
+model behind a prompt, a third-party API, a tool, a subprocess. Give it
+a name once. Kredisco creates its identity and reuses it forever after.
+
+```python
+extractor = kd.agent("invoice-extractor")
+reviewer  = kd.agent("code-reviewer")
+```
+
+### 5. Route your calls through `track`
+
+Take the call you already make:
+
+```python
+data = extract_invoice(pdf)
+```
+
+Hand the function to `track` instead of calling it yourself:
+
+```python
+data = kd.track(extractor, "extract", extract_invoice, pdf)
+```
+
+Four arguments: the agent, a label for the kind of work, **the function
+without parentheses**, then its arguments.
+
+Kredisco calls the function, times it, files a record, and hands back
+exactly what your function returned. If it raises, the failure is
+recorded and the exception propagates normally. Your logic does not
+change.
+
+That is the integration. Scores start appearing on the dashboard.
+
+---
+
+## Telling Kredisco what counts as a failure
+
+By default a task fails only if your function raises.
+
+Most pipelines have a stricter rule — a required field, a schema, a
+minimum length. Pass `validate` and Kredisco uses yours:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+)
+```
+
+**This matters more than it looks.** With no validator and nothing
+raising, every task passes, and the largest factor in the score is
+measuring nothing. Kredisco is worth most to pipelines that already
+check their own output.
+
+## Retries
+
+Add `retries=1` and a failed attempt runs again. Kredisco links the
+retry to the original task, and that link is what drives the rework
+factor:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+)
+```
+
+If your orchestrator already retries on its own, leave this off and use
+the context manager below for each attempt.
+
+## When everything fails
+
+If every attempt fails, `track` re-raises the last exception. Sometimes
+that is what you want. Often it is not — a graph node that stops the
+whole run because one step returned bad JSON is worse than a node that
+carries on with an empty value.
+
+Pass `default` and `track` returns it instead of raising:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+    default={},
+)
+```
+
+The failure is still recorded and the score still drops. Only your
+control flow changes.
+
+Without `default`, every call site needs its own `try`/`except`. With
+it, a pipeline step is one expression:
+
+```python
+def extract_node(state):
+    return {"fields": kd.track(
+        extractor, "extract", extract_invoice, state["pdf"],
+        validate=fields_ok, retries=1, default={},
+    )}
+```
+
+## When you cannot hand over a function
+
+Some code will not collapse into a single call — the body of a graph
+node, a streamed response consumed in pieces, a block with setup and
+teardown around it. Open a task and report the outcome yourself:
+
+```python
+with kd.task(reviewer, "review") as t:
+    findings = run_review(diff)
+    t.accepted = len(findings) > 0
+```
+
+The clock starts when the block opens and stops when it closes. An
+exception inside records a failure and re-raises.
+
+## Grouping by pipeline
+
+If you run more than one pipeline, tag each one. Same key, different
+label — they appear as separate groups on the dashboard but roll up to
+one organization.
+
+```python
+kd = Kredisco(
+    api_key=os.environ["KREDISCO_API_KEY"],
+    workflow_id="invoice-ingest",
+)
+```
+
+## Reading scores
+
+```python
+kd.score(extractor.pubkey)         # one number, 300–850
+kd.breakdown(extractor.pubkey)     # what the score is made of
+kd.dashboard()                     # your agents, grouped by pipeline
+kd.best("extract", minimum=650)    # highest scorer for a kind of work
+```
+
+`best` is the point of the whole thing: pick who does the work by track
+record instead of hardcoding a vendor and hoping.
+
+## Things worth knowing
+
+**Reporting never breaks your pipeline.** If Kredisco is unreachable or
+your key is rejected, the failure is logged and your work continues.
+
+```python
+import logging
+logging.getLogger("kredisco").setLevel(logging.INFO)
+```
+
+**Agent keys live on disk.** Kredisco writes each agent's keypair to
+`.kredisco/`. That directory *is* your agents' identity — lose it and
+every score resets to 300. Back it up, and add it to `.gitignore`.
+
+**Timestamps come from the SDK**, not from your agent, so an agent
+cannot shorten its own recorded duration.
+
+---
+
+---
+
+## A working example
+
+[`examples/langgraph_support_triage.py`](examples/langgraph_support_triage.py)
+is a four-agent LangGraph pipeline built on two different Claude models,
+with a validator on every step.
+
+Run it a few times. The scores separate for real reasons — one agent
+returns JSON wrapped in code fences, another hits a response shape the
+caller did not expect, a third is simply slower. Fix the prompt that is
+failing and watch that agent climb over subsequent runs, without ever
+catching the agent that never failed.
+
+That gap is the point. History has weight, and recovery takes work.
+
+---
+
+## What this does not solve
+
+**A dishonest reporter can fabricate everything.** Signatures prove who
+signed, not that the content is true. Credit bureaus have the same hole
+and handle it with licensing and liability rather than cryptography.
+Kredisco's mitigation is that keys are tied to GitHub accounts and the
+diversity factor requires many distinct organizations.
+
+**Identity is still cheap.** A bad score can be abandoned for a fresh
+keypair. Starting at the floor makes that costly, not impossible.
+
+**One score across all task types.** An agent good at summarising and
+bad at code review averages into noise.
+
+**Rate limiting is per-process** and does not survive horizontal
+scaling.
+
+**No test suite.** The scoring model has changed several times and was
+verified by inspection.
+
+---
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/reachrshah)
+[![GitHub](https://img.shields.io/badge/GitHub-14161A?style=for-the-badge&logo=github&logoColor=white)](https://github.com/idfwyy)

kredisco-0.1.0/kredisco/__init__.py

@@ -0,0 +1,5 @@
+from kredisco.client import Kredisco
+from kredisco.identity import Keypair
+from kredisco.receipt import Receipt
+
+__all__ = ["Kredisco", "Keypair", "Receipt"]

kredisco-0.1.0/kredisco/client.py

@@ -0,0 +1,238 @@
+import logging
+import os
+import time
+import uuid
+from contextlib import contextmanager
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+try:
+    from kredisco.identity import Keypair
+    from kredisco.receipt import Receipt
+except ModuleNotFoundError:
+    from identity import Keypair
+    from receipt import Receipt
+
+DEFAULT_SERVER = "https://api.kredisco.com"
+DEFAULT_TIMEOUT = 10.0
+DEFAULT_BUDGET = 30.0
+DEFAULT_KEY_DIR = ".kredisco"
+_RAISE = object()
+
+logger = logging.getLogger("kredisco")
+
+
+class KrediscoError(Exception):
+    pass
+
+
+class Agent:
+
+    def __init__(self, name, specialty, keypair):
+        self.name = name
+        self.specialty = specialty
+        self.keypair = keypair
+
+    @property
+    def pubkey(self):
+        return self.keypair.public_key_hex()
+
+    def __repr__(self):
+        return "<Agent {} {}>".format(self.name, self.pubkey[:8])
+
+
+class Task:
+
+    def __init__(self):
+        self.accepted = True
+        self.result = None
+        self.error = None
+
+
+class Kredisco:
+
+    def __init__(self, api_key=None, workflow_id=None, server=None,
+                 key_dir=None, timeout=DEFAULT_TIMEOUT, budget=DEFAULT_BUDGET):
+        self.api_key = api_key or os.environ.get("KREDISCO_API_KEY")
+        if not self.api_key:
+            raise KrediscoError(
+                "No API key. Pass api_key= or set KREDISCO_API_KEY. "
+                "Create one at your Kredisco dashboard."
+            )
+
+        self.workflow_id = workflow_id
+        self.server = (server or os.environ.get("KREDISCO_SERVER")
+                       or DEFAULT_SERVER).rstrip("/")
+        self.key_dir = key_dir or os.environ.get("KREDISCO_KEY_DIR", DEFAULT_KEY_DIR)
+        self.timeout = timeout
+        self.budget = budget
+
+        self.session = self._build_session()
+        self.caller = Keypair.load_or_create(
+            os.path.join(self.key_dir, "orchestrator.key")
+        )
+        self._registered = set()
+
+    # ---------- plumbing ----------
+
+    def _build_session(self):
+        session = requests.Session()
+        session.headers["Authorization"] = "Bearer " + self.api_key
+        retry = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET", "POST"],
+            respect_retry_after_header=True,
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        return session
+
+    def _post(self, path, payload):
+        try:
+            res = self.session.post(self.server + path, json=payload,
+                                    timeout=self.timeout)
+        except requests.RequestException as exc:
+            logger.warning("kredisco: %s unreachable (%s)", path, exc)
+            return None
+        if res.status_code == 401:
+            logger.error("kredisco: API key rejected")
+        elif res.status_code >= 400:
+            logger.warning("kredisco: %s returned %s %s",
+                           path, res.status_code, res.text[:200])
+        return res
+
+    def _get(self, path):
+        try:
+            res = self.session.get(self.server + path, timeout=self.timeout)
+        except requests.RequestException as exc:
+            raise KrediscoError("Could not reach Kredisco: {}".format(exc))
+        if res.status_code >= 400:
+            raise KrediscoError("{} returned {}".format(path, res.status_code))
+        return res.json()
+
+    # ---------- agents ----------
+
+    def agent(self, name, specialty=None):
+        keypair = Keypair.load_or_create(
+            os.path.join(self.key_dir, "agents", name + ".key")
+        )
+        agent = Agent(name, specialty or name, keypair)
+
+        if agent.pubkey not in self._registered:
+            self._post("/register", {
+                "pubkey": agent.pubkey,
+                "name": agent.name,
+                "specialty": agent.specialty,
+            })
+            self._registered.add(agent.pubkey)
+
+        return agent
+
+    # ---------- reporting ----------
+
+    def _report(self, agent, task_type, started_at, delivered_at,
+                accepted, deadline, parent_task_id=None):
+        task_id = str(uuid.uuid4())
+        receipt = Receipt(
+            task_id, task_type, deadline, started_at, delivered_at,
+            accepted, parent_task_id=parent_task_id,
+        )
+        receipt.sign_by(agent.keypair, "specialist")
+        receipt.sign_by(self.caller, "hiring")
+
+        self._post("/settle", {
+            "task_id": task_id,
+            "task_type": task_type,
+            "deadline": deadline,
+            "started_at": started_at,
+            "delivered_at": delivered_at,
+            "accepted": accepted,
+            "specialist_sig": receipt.specialist_sig,
+            "hiring_sig": receipt.hiring_sig,
+            "specialist_pubkey": agent.pubkey,
+            "hiring_pubkey": self.caller.public_key_hex(),
+            "agent_id": agent.pubkey,
+            "caller_id": self.caller.public_key_hex(),
+            "parent_task_id": parent_task_id,
+            "workflow_id": self.workflow_id,
+        })
+        return task_id
+
+    def track(self, agent, task_type, fn, *args,
+              validate=None, budget=None, retries=0, default=_RAISE, **kwargs):
+        parent_task_id = None
+        attempts = retries + 1
+        last_error = None
+
+        for attempt in range(attempts):
+            started_at = time.time()
+            deadline = started_at + (budget or self.budget)
+            accepted = True
+            result = None
+            last_error = None
+
+            try:
+                result = fn(*args, **kwargs)
+                if validate is not None:
+                    accepted = bool(validate(result))
+            except Exception as exc:
+                accepted = False
+                last_error = exc
+
+            delivered_at = time.time()
+            task_id = self._report(agent, task_type, started_at, delivered_at,
+                                   accepted, deadline, parent_task_id)
+
+            if accepted:
+                return result
+
+            parent_task_id = task_id
+            if attempt < attempts - 1:
+                logger.info("kredisco: retrying %s on %s", task_type, agent.name)
+
+        if default is not _RAISE:
+            logger.info("kredisco: %s on %s failed, returning default",
+                        task_type, agent.name)
+            return default
+
+        if last_error is not None:
+            raise last_error
+        return result
+    @contextmanager
+    def task(self, agent, task_type, budget=None, parent_task_id=None):
+        started_at = time.time()
+        deadline = started_at + (budget or self.budget)
+        handle = Task()
+        try:
+            yield handle
+        except Exception:
+            handle.accepted = False
+            self._report(agent, task_type, started_at, time.time(),
+                         False, deadline, parent_task_id)
+            raise
+        self._report(agent, task_type, started_at, time.time(),
+                     handle.accepted, deadline, parent_task_id)
+
+    # ---------- reading ----------
+
+    def score(self, pubkey):
+        return self._get("/score/" + pubkey)["score"]
+
+    def breakdown(self, pubkey):
+        return self._get("/agent/" + pubkey + "/breakdown")
+
+    def dashboard(self):
+        return self._get("/dashboard")["workflows"]
+
+    def leaderboard(self):
+        return self._get("/leaderboard")["leaderboard"]
+
+    def best(self, specialty, minimum=0):
+        rows = [r for r in self.leaderboard()
+                if r.get("specialty") == specialty and r["score"] >= minimum]
+        return rows[0] if rows else None

kredisco-0.1.0/kredisco/identity.py

@@ -0,0 +1,76 @@
+import os
+from pathlib import Path
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric import ed25519
+
+
+class Keypair:
+
+    def __init__(self, private_key=None):
+        self.private_key = private_key or ed25519.Ed25519PrivateKey.generate()
+        self.public_key = self.private_key.public_key()
+
+    def public_key_hex(self) -> str:
+        return self.public_key.public_bytes_raw().hex()
+
+    def private_key_hex(self) -> str:
+        return self.private_key.private_bytes_raw().hex()
+
+    @classmethod
+    def from_hex(cls, private_key_hex: str) -> "Keypair":
+        raw = bytes.fromhex(private_key_hex)
+        if len(raw) != 32:
+            raise ValueError("private key must be 32 bytes")
+        return cls(ed25519.Ed25519PrivateKey.from_private_bytes(raw))
+
+    def save(self, path) -> None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.private_key_hex())
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+
+    @classmethod
+    def load(cls, path) -> "Keypair":
+        return cls.from_hex(Path(path).read_text().strip())
+
+    @classmethod
+    def load_or_create(cls, path) -> "Keypair":
+        path = Path(path)
+        if path.exists():
+            try:
+                return cls.load(path)
+            except (ValueError, OSError):
+                pass
+        keypair = cls()
+        keypair.save(path)
+        return keypair
+
+    def sign(self, message: str) -> str:
+        return self.private_key.sign(message.encode()).hex()
+
+    @staticmethod
+    def verify(public_key_hex: str, message: str, signature_hex: str) -> bool:
+        if not public_key_hex or not signature_hex or message is None:
+            return False
+        try:
+            raw = bytes.fromhex(public_key_hex)
+            key_obj = ed25519.Ed25519PublicKey.from_public_bytes(raw)
+            key_obj.verify(bytes.fromhex(signature_hex), message.encode())
+            return True
+        except (InvalidSignature, ValueError, TypeError):
+            return False
+
+
+if __name__ == "__main__":
+    kp = Keypair()
+    print("agent ID:", kp.public_key_hex())
+    sig = kp.sign("hello")
+    print("real:", Keypair.verify(kp.public_key_hex(), "hello", sig))
+    print("fake:", Keypair.verify(kp.public_key_hex(), "hacked", sig))
+
+    restored = Keypair.from_hex(kp.private_key_hex())
+    print("restored matches:", restored.public_key_hex() == kp.public_key_hex())

kredisco-0.1.0/kredisco/receipt.py

@@ -0,0 +1,57 @@
+import json
+try:
+    from kredisco.identity import Keypair    
+except ModuleNotFoundError:
+    from identity import Keypair 
+                 
+class Receipt:
+    def __init__(self, task_id, task_type, deadline, started_at, delivered_at, accepted, specialist_sig = None , hiring_sig = None, parent_task_id = None):
+        self.task_id = task_id
+        self.task_type = task_type
+        self.deadline = deadline
+        self.started_at = started_at
+        self.delivered_at = delivered_at
+        self.accepted = accepted
+        self.specialist_sig = specialist_sig
+        self.hiring_sig = hiring_sig
+        self.parent_task_id = parent_task_id
+
+    def to_text(self) -> str:
+        data = {
+            "task_id" : self.task_id,
+            "task_type" : self.task_type,
+            "deadline" : self.deadline,
+            "started_at": self.started_at,
+            "delivered_at" : self.delivered_at,
+            "accepted" : self.accepted
+            }
+        return json.dumps(data, sort_keys=True)
+
+    def sign_by(self, keypair, role) -> str:
+        sig = keypair.sign(self.to_text())
+        if role == "specialist":
+            self.specialist_sig = sig
+        else:
+            self.hiring_sig = sig
+        return sig
+
+
+    def verify_signatures(self,specialist_pubkey,hiring_pubkey) -> bool:
+        return Keypair.verify( specialist_pubkey , self.to_text() , self.specialist_sig ) and Keypair.verify( hiring_pubkey , self.to_text() , self.hiring_sig )
+        
+        
+
+        
+if __name__ == "__main__":
+    specialist = Keypair()
+    hiring = Keypair()
+
+    r = Receipt("47", "summarize", 100.0, 90.0, 95.0, True)
+    r.sign_by(specialist, "specialist")
+    r.sign_by(hiring, "hiring")
+
+    print("both valid:", r.verify_signatures(specialist.public_key_hex(), hiring.public_key_hex()))
+
+    fake = Receipt("99", "summarize", 100.0, 90.0, 95.0, True)
+    fake.sign_by(specialist, "specialist")   # only specialist signs, no hiring countersign
+    print("faker valid:", fake.verify_signatures(specialist.public_key_hex(), hiring.public_key_hex()))

kredisco-0.1.0/kredisco.egg-info/PKG-INFO

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: kredisco
+Version: 0.1.0
+Summary: A trust layer for AI agents
+Author: Rahul Sah
+License-Expression: MIT
+Project-URL: Homepage, https://kredisco.com
+Project-URL: Source, https://github.com/kredisco/Kredisco
+Keywords: ai,agents,trust,reputation,llm,langgraph
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: cryptography>=41.0
+
+# Kredisco
+
+**A trust layer for AI agents.**
+
+Humans carry a credit score. It follows you between lenders, it is held
+by a bureau rather than by you, and it is built from what other parties
+report about your behaviour. A landlord who has never met you can decide
+whether to trust you in seconds.
+
+AI agents have no equivalent. You wire one into your pipeline and have
+no idea whether it is dependable until something breaks.
+
+Kredisco gives every agent a portable trust score, 300 to 850, earned
+from its real track record and held where the agent cannot reach it.
+
+---
+
+## Why agents need one
+
+A pipeline with six agents fails quietly. One step degrades, output
+quality drops, and you find out from a user complaint days later.
+Nothing tells you which agent to stop calling.
+
+The instinct is to ask the agents, or to collect ratings. Neither
+survives contact with incentives. An agent will always report that it
+did well. Open rating systems get farmed: an audit of ERC-8004's on-chain
+reputation registry found the large majority of reviewers exhibited
+coordinated Sybil behaviour, and after removing them most rated agents
+had no valid feedback left.
+
+Credit scoring solved this problem a long time ago, and not with better
+surveys. It solved it structurally: **the party being scored is never
+the party reporting.** Your bank reports your payments. You cannot file
+your own. You cannot edit the file. You cannot see the number until
+someone pulls it.
+
+Kredisco applies that structure to agents.
+
+## What the score is made of
+
+Like FICO, the score is a weighted blend of factors, and like FICO,
+every one of them comes from somewhere the scored party cannot reach.
+
+| Factor | Weight | Where it comes from |
+|---|---:|---|
+| Rework rate (inverted) | 0.45 | You retried, reassigned, or the next step errored |
+| On-time rate | 0.20 | Measured by the SDK wrapping the call |
+| Counterparty diversity | 0.20 | How many distinct organizations hired it |
+| History depth | 0.15 | Volume of recorded work |
+
+Scores run 300–850. A new agent scores 300, so abandoning a damaged
+identity means abandoning everything it earned.
+
+Rework carries the most weight because it is hardest to fake. An agent
+cannot retry itself, cannot stop a downstream step from failing, and
+cannot stop you from routing around it.
+
+## Who reports, and why it can't be gamed
+
+A lender reports your payment to the bureau. The bureau holds the file.
+A future lender queries the bureau, never you.
+
+Kredisco works the same way. Your orchestrator is the reporter, Kredisco
+is the bureau, and the agent is the subject:
+
+1. Your agent completes a task
+2. The agent signs a record of it; your orchestrator countersigns
+3. Your orchestrator submits it, authenticated with your API key
+4. Kredisco verifies both signatures and files it under your organization
+5. The score is recomputed from everything on file
+
+Both signatures are required, so neither side can act alone. An agent
+cannot manufacture a history, because every entry needs a real
+counterparty to have signed it. And it never holds its own score — when
+someone wants to know whether to trust it, they ask Kredisco.
+
+---
+
+## Quickstart
+
+### 1. Get a key
+
+Sign in with GitHub at the Kredisco dashboard and create an API key. One
+key covers everything you build.
+
+```bash
+export KREDISCO_API_KEY=kd_...
+```
+
+### 2. Install
+
+```bash
+pip install kredisco
+```
+
+### 3. Connect
+
+```python
+import os
+from kredisco import Kredisco
+
+kd = Kredisco(api_key=os.environ["KREDISCO_API_KEY"])
+```
+
+### 4. Name each agent you want scored
+
+An "agent" is any component you call and could imagine replacing: a
+model behind a prompt, a third-party API, a tool, a subprocess. Give it
+a name once. Kredisco creates its identity and reuses it forever after.
+
+```python
+extractor = kd.agent("invoice-extractor")
+reviewer  = kd.agent("code-reviewer")
+```
+
+### 5. Route your calls through `track`
+
+Take the call you already make:
+
+```python
+data = extract_invoice(pdf)
+```
+
+Hand the function to `track` instead of calling it yourself:
+
+```python
+data = kd.track(extractor, "extract", extract_invoice, pdf)
+```
+
+Four arguments: the agent, a label for the kind of work, **the function
+without parentheses**, then its arguments.
+
+Kredisco calls the function, times it, files a record, and hands back
+exactly what your function returned. If it raises, the failure is
+recorded and the exception propagates normally. Your logic does not
+change.
+
+That is the integration. Scores start appearing on the dashboard.
+
+---
+
+## Telling Kredisco what counts as a failure
+
+By default a task fails only if your function raises.
+
+Most pipelines have a stricter rule — a required field, a schema, a
+minimum length. Pass `validate` and Kredisco uses yours:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+)
+```
+
+**This matters more than it looks.** With no validator and nothing
+raising, every task passes, and the largest factor in the score is
+measuring nothing. Kredisco is worth most to pipelines that already
+check their own output.
+
+## Retries
+
+Add `retries=1` and a failed attempt runs again. Kredisco links the
+retry to the original task, and that link is what drives the rework
+factor:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+)
+```
+
+If your orchestrator already retries on its own, leave this off and use
+the context manager below for each attempt.
+
+## When everything fails
+
+If every attempt fails, `track` re-raises the last exception. Sometimes
+that is what you want. Often it is not — a graph node that stops the
+whole run because one step returned bad JSON is worse than a node that
+carries on with an empty value.
+
+Pass `default` and `track` returns it instead of raising:
+
+```python
+data = kd.track(
+    extractor, "extract", extract_invoice, pdf,
+    validate=lambda d: d is not None and "total" in d,
+    retries=1,
+    default={},
+)
+```
+
+The failure is still recorded and the score still drops. Only your
+control flow changes.
+
+Without `default`, every call site needs its own `try`/`except`. With
+it, a pipeline step is one expression:
+
+```python
+def extract_node(state):
+    return {"fields": kd.track(
+        extractor, "extract", extract_invoice, state["pdf"],
+        validate=fields_ok, retries=1, default={},
+    )}
+```
+
+## When you cannot hand over a function
+
+Some code will not collapse into a single call — the body of a graph
+node, a streamed response consumed in pieces, a block with setup and
+teardown around it. Open a task and report the outcome yourself:
+
+```python
+with kd.task(reviewer, "review") as t:
+    findings = run_review(diff)
+    t.accepted = len(findings) > 0
+```
+
+The clock starts when the block opens and stops when it closes. An
+exception inside records a failure and re-raises.
+
+## Grouping by pipeline
+
+If you run more than one pipeline, tag each one. Same key, different
+label — they appear as separate groups on the dashboard but roll up to
+one organization.
+
+```python
+kd = Kredisco(
+    api_key=os.environ["KREDISCO_API_KEY"],
+    workflow_id="invoice-ingest",
+)
+```
+
+## Reading scores
+
+```python
+kd.score(extractor.pubkey)         # one number, 300–850
+kd.breakdown(extractor.pubkey)     # what the score is made of
+kd.dashboard()                     # your agents, grouped by pipeline
+kd.best("extract", minimum=650)    # highest scorer for a kind of work
+```
+
+`best` is the point of the whole thing: pick who does the work by track
+record instead of hardcoding a vendor and hoping.
+
+## Things worth knowing
+
+**Reporting never breaks your pipeline.** If Kredisco is unreachable or
+your key is rejected, the failure is logged and your work continues.
+
+```python
+import logging
+logging.getLogger("kredisco").setLevel(logging.INFO)
+```
+
+**Agent keys live on disk.** Kredisco writes each agent's keypair to
+`.kredisco/`. That directory *is* your agents' identity — lose it and
+every score resets to 300. Back it up, and add it to `.gitignore`.
+
+**Timestamps come from the SDK**, not from your agent, so an agent
+cannot shorten its own recorded duration.
+
+---
+
+---
+
+## A working example
+
+[`examples/langgraph_support_triage.py`](examples/langgraph_support_triage.py)
+is a four-agent LangGraph pipeline built on two different Claude models,
+with a validator on every step.
+
+Run it a few times. The scores separate for real reasons — one agent
+returns JSON wrapped in code fences, another hits a response shape the
+caller did not expect, a third is simply slower. Fix the prompt that is
+failing and watch that agent climb over subsequent runs, without ever
+catching the agent that never failed.
+
+That gap is the point. History has weight, and recovery takes work.
+
+---
+
+## What this does not solve
+
+**A dishonest reporter can fabricate everything.** Signatures prove who
+signed, not that the content is true. Credit bureaus have the same hole
+and handle it with licensing and liability rather than cryptography.
+Kredisco's mitigation is that keys are tied to GitHub accounts and the
+diversity factor requires many distinct organizations.
+
+**Identity is still cheap.** A bad score can be abandoned for a fresh
+keypair. Starting at the floor makes that costly, not impossible.
+
+**One score across all task types.** An agent good at summarising and
+bad at code review averages into noise.
+
+**Rate limiting is per-process** and does not survive horizontal
+scaling.
+
+**No test suite.** The scoring model has changed several times and was
+verified by inspection.
+
+---
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/reachrshah)
+[![GitHub](https://img.shields.io/badge/GitHub-14161A?style=for-the-badge&logo=github&logoColor=white)](https://github.com/idfwyy)

kredisco-0.1.0/kredisco.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+kredisco/__init__.py
+kredisco/client.py
+kredisco/identity.py
+kredisco/receipt.py
+kredisco.egg-info/PKG-INFO
+kredisco.egg-info/SOURCES.txt
+kredisco.egg-info/dependency_links.txt
+kredisco.egg-info/requires.txt
+kredisco.egg-info/top_level.txt

kredisco-0.1.0/kredisco.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kredisco-0.1.0/kredisco.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.28
+cryptography>=41.0

kredisco-0.1.0/kredisco.egg-info/top_level.txt

@@ -0,0 +1 @@
+kredisco

kredisco-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kredisco"
+version = "0.1.0"
+description = "A trust layer for AI agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Rahul Sah"}]
+keywords = ["ai", "agents", "trust", "reputation", "llm", "langgraph"]
+dependencies = [
+    "requests>=2.28",
+    "cryptography>=41.0",
+]
+
+[project.urls]
+Homepage = "https://kredisco.com"
+Source = "https://github.com/kredisco/Kredisco"
+
+[tool.setuptools]
+packages = ["kredisco"]

kredisco-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+