computeid-sdk 1.0.0__tar.gz

computeid_sdk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ComputeID
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

computeid_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: computeid-sdk
+Version: 1.0.0
+Summary: Cryptographic identity for AI compute infrastructure and agentic AI systems
+Home-page: https://github.com/trustedaicompute-ops/computeid-sdk
+Author: ComputeID
+Author-email: hello@compute-id.com
+Keywords: gpu identity certificates quantum-safe ai agents security cryptography
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ComputeID SDK
+
+**Cryptographic identity for AI compute infrastructure and agentic AI systems.**
+
+> Every GPU needs a passport. Every AI agent needs an identity.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.0.0-blue)](https://pypi.org/project/computeid-sdk/)
+[![compute-id.com](https://img.shields.io/badge/docs-compute--id.com-00b4ff)](https://compute-id.com)
+
+---
+
+## What is ComputeID?
+
+ComputeID provides two things:
+
+1. **DeviceID** — Cryptographic passports for GPUs, servers, and compute hardware
+2. **AgentID** — Cryptographic passports for AI agents and autonomous systems
+
+Think of it as a passport system for AI infrastructure. Every device and every agent gets a unique cryptographic identity, a certificate of what it is allowed to do, and an immutable audit trail of everything it has done.
+
+---
+
+## Installation
+
+```bash
+pip install computeid-sdk
+```
+
+---
+
+## Quick Start
+
+### GPU / Device Identity
+
+```python
+from computeid import register_gpu
+
+# Register a GPU and get a cryptographic passport
+passport = register_gpu(
+    name="NVIDIA A100 #1",
+    ip_address="192.168.1.10",
+    api_key="your-api-key"  # optional for free tier
+)
+
+print(passport.device_code)  # GPU-001
+print(passport.is_valid())   # True
+```
+
+### AI Agent Identity
+
+```python
+from computeid import issue_agent_passport
+
+# Issue a passport for your AI agent
+passport = issue_agent_passport(
+    agent_name="ResearchAgent",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    trust_level="standard",
+    model="claude-sonnet-4-5"
+)
+
+# Check if trusted before giving access
+if passport.is_trusted():
+    run_your_agent(passport=passport)
+
+# Log every action the agent takes
+passport.log_action("web_search", {"query": "market research"}, "success")
+
+# Revoke instantly if needed
+passport.revoke(reason="Unexpected behaviour detected")
+```
+
+---
+
+## Agent Trust Levels
+
+| Level | Description | Use Case |
+|-------|-------------|----------|
+| `restricted` | Read only, human oversight required | Testing, low-risk tasks |
+| `standard` | Web browsing, API calls, file read | Most production agents |
+| `elevated` | Code execution, spawn child agents | Advanced automation |
+| `autonomous` | Full autonomy | Mission-critical systems |
+
+---
+
+## Full Example — Agentic AI with PassportSystem
+
+```python
+from computeid import (
+    AgentPassport,
+    AgentCapabilities,
+    TrustRegistry,
+    requires_passport
+)
+
+# 1. Create capabilities for your agent
+caps = AgentCapabilities(
+    can_browse_web=True,
+    can_call_apis=True,
+    can_execute_code=False,   # not allowed
+    trust_level="standard",
+    human_in_loop=True,
+    max_actions_per_hour=100
+)
+
+# 2. Issue a passport
+passport = AgentPassport.issue(
+    agent_name="DataAnalysisAgent",
+    agent_type="analyst",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=caps,
+    model="claude-sonnet-4-5",
+    version="2.1.0"
+)
+
+# 3. Protect your functions with passport checks
+@requires_passport(capability="browse_web")
+def search_web(query: str, passport: AgentPassport):
+    # This function can only be called by agents
+    # with a valid passport that has browse_web capability
+    results = do_search(query)
+    return results
+
+# 4. Call protected function
+results = search_web("GPU rental prices", passport=passport)
+
+# 5. View the audit trail
+for entry in passport.get_audit_log():
+    print(f"{entry['timestamp']} | {entry['action']} | {entry['outcome']}")
+
+# 6. Multi-agent trust chain
+orchestrator = AgentPassport.issue(
+    agent_name="OrchestratorAgent",
+    agent_type="orchestrator",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.elevated(),
+    model="claude-opus-4-6"
+)
+
+# Spawn a child agent — only works if orchestrator has can_spawn_agents=True
+child_agent = AgentPassport.issue(
+    agent_name="SubAgent-1",
+    agent_type="worker",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.standard(),
+    model="claude-sonnet-4-5",
+    parent_passport=orchestrator   # establishes trust chain
+)
+
+# 7. Organisation-wide trust registry
+registry = TrustRegistry(org_name="Acme Corp")
+registry.register_agent(orchestrator)
+registry.register_agent(child_agent)
+
+# Check trust
+if registry.is_trusted(child_agent.agent_id):
+    print("Agent is trusted")
+
+# Get full audit report
+report = registry.get_audit_report()
+print(f"Total agents: {report['total_agents']}")
+print(f"Active agents: {report['active_agents']}")
+```
+
+---
+
+## Why Agent Passports Matter
+
+The rise of agentic AI creates a new security challenge:
+
+- **Who built this agent?** — No way to verify
+- **What is it allowed to do?** — No standard capability model
+- **What has it done?** — No audit trail
+- **Can we stop it?** — No revocation mechanism
+- **Which agents trust each other?** — No trust chain
+
+ComputeID AgentID solves all of these with cryptographic guarantees.
+
+---
+
+## Free Tier
+
+| Feature | Free | Growth ($499/mo) | Enterprise ($1,999/mo) |
+|---------|------|------------------|------------------------|
+| Device passports | 3 devices | 50 devices | Unlimited |
+| Agent passports | 5 agents | 100 agents | Unlimited |
+| Audit log retention | 7 days | 90 days | 1 year |
+| Quantum-safe certs | ❌ | ✅ | ✅ |
+| Custom CA | ❌ | ❌ | ✅ |
+| API access | ✅ | ✅ | ✅ |
+
+**Get started free at [compute-id.com](https://compute-id.com)**
+
+---
+
+## Regulatory Compliance
+
+ComputeID helps you meet:
+
+- **EU AI Act** — requires audit trails for high-risk AI systems
+- **NIST AI RMF** — AI risk management framework
+- **SOC2 Type II** — compute infrastructure audit logs
+- **NSA CNSA 2.0** — post-quantum cryptography by 2030
+
+---
+
+## Contributing
+
+ComputeID SDK is open source under the MIT license.
+
+We welcome contributions — especially:
+- Client libraries for other languages (Go, Rust, Java)
+- Integration examples with popular AI frameworks
+- Protocol specification improvements
+
+```bash
+git clone https://github.com/trustedaicompute-ops/computeid-sdk
+cd computeid-sdk
+pip install -e ".[dev]"
+```
+
+---
+
+## Links
+
+- **Website:** [compute-id.com](https://compute-id.com)
+- **Dashboard:** [aicomputeid.com](https://aicomputeid.com)
+- **GitHub:** [github.com/trustedaicompute-ops](https://github.com/trustedaicompute-ops)
+- **Email:** hello@compute-id.com
+
+---
+
+## License
+
+MIT License — free to use, modify and distribute.
+
+Copyright 2026 ComputeID / TrustedAI Compute

computeid_sdk-1.0.0/README.md

@@ -0,0 +1,242 @@
+# ComputeID SDK
+
+**Cryptographic identity for AI compute infrastructure and agentic AI systems.**
+
+> Every GPU needs a passport. Every AI agent needs an identity.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.0.0-blue)](https://pypi.org/project/computeid-sdk/)
+[![compute-id.com](https://img.shields.io/badge/docs-compute--id.com-00b4ff)](https://compute-id.com)
+
+---
+
+## What is ComputeID?
+
+ComputeID provides two things:
+
+1. **DeviceID** — Cryptographic passports for GPUs, servers, and compute hardware
+2. **AgentID** — Cryptographic passports for AI agents and autonomous systems
+
+Think of it as a passport system for AI infrastructure. Every device and every agent gets a unique cryptographic identity, a certificate of what it is allowed to do, and an immutable audit trail of everything it has done.
+
+---
+
+## Installation
+
+```bash
+pip install computeid-sdk
+```
+
+---
+
+## Quick Start
+
+### GPU / Device Identity
+
+```python
+from computeid import register_gpu
+
+# Register a GPU and get a cryptographic passport
+passport = register_gpu(
+    name="NVIDIA A100 #1",
+    ip_address="192.168.1.10",
+    api_key="your-api-key"  # optional for free tier
+)
+
+print(passport.device_code)  # GPU-001
+print(passport.is_valid())   # True
+```
+
+### AI Agent Identity
+
+```python
+from computeid import issue_agent_passport
+
+# Issue a passport for your AI agent
+passport = issue_agent_passport(
+    agent_name="ResearchAgent",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    trust_level="standard",
+    model="claude-sonnet-4-5"
+)
+
+# Check if trusted before giving access
+if passport.is_trusted():
+    run_your_agent(passport=passport)
+
+# Log every action the agent takes
+passport.log_action("web_search", {"query": "market research"}, "success")
+
+# Revoke instantly if needed
+passport.revoke(reason="Unexpected behaviour detected")
+```
+
+---
+
+## Agent Trust Levels
+
+| Level | Description | Use Case |
+|-------|-------------|----------|
+| `restricted` | Read only, human oversight required | Testing, low-risk tasks |
+| `standard` | Web browsing, API calls, file read | Most production agents |
+| `elevated` | Code execution, spawn child agents | Advanced automation |
+| `autonomous` | Full autonomy | Mission-critical systems |
+
+---
+
+## Full Example — Agentic AI with PassportSystem
+
+```python
+from computeid import (
+    AgentPassport,
+    AgentCapabilities,
+    TrustRegistry,
+    requires_passport
+)
+
+# 1. Create capabilities for your agent
+caps = AgentCapabilities(
+    can_browse_web=True,
+    can_call_apis=True,
+    can_execute_code=False,   # not allowed
+    trust_level="standard",
+    human_in_loop=True,
+    max_actions_per_hour=100
+)
+
+# 2. Issue a passport
+passport = AgentPassport.issue(
+    agent_name="DataAnalysisAgent",
+    agent_type="analyst",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=caps,
+    model="claude-sonnet-4-5",
+    version="2.1.0"
+)
+
+# 3. Protect your functions with passport checks
+@requires_passport(capability="browse_web")
+def search_web(query: str, passport: AgentPassport):
+    # This function can only be called by agents
+    # with a valid passport that has browse_web capability
+    results = do_search(query)
+    return results
+
+# 4. Call protected function
+results = search_web("GPU rental prices", passport=passport)
+
+# 5. View the audit trail
+for entry in passport.get_audit_log():
+    print(f"{entry['timestamp']} | {entry['action']} | {entry['outcome']}")
+
+# 6. Multi-agent trust chain
+orchestrator = AgentPassport.issue(
+    agent_name="OrchestratorAgent",
+    agent_type="orchestrator",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.elevated(),
+    model="claude-opus-4-6"
+)
+
+# Spawn a child agent — only works if orchestrator has can_spawn_agents=True
+child_agent = AgentPassport.issue(
+    agent_name="SubAgent-1",
+    agent_type="worker",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.standard(),
+    model="claude-sonnet-4-5",
+    parent_passport=orchestrator   # establishes trust chain
+)
+
+# 7. Organisation-wide trust registry
+registry = TrustRegistry(org_name="Acme Corp")
+registry.register_agent(orchestrator)
+registry.register_agent(child_agent)
+
+# Check trust
+if registry.is_trusted(child_agent.agent_id):
+    print("Agent is trusted")
+
+# Get full audit report
+report = registry.get_audit_report()
+print(f"Total agents: {report['total_agents']}")
+print(f"Active agents: {report['active_agents']}")
+```
+
+---
+
+## Why Agent Passports Matter
+
+The rise of agentic AI creates a new security challenge:
+
+- **Who built this agent?** — No way to verify
+- **What is it allowed to do?** — No standard capability model
+- **What has it done?** — No audit trail
+- **Can we stop it?** — No revocation mechanism
+- **Which agents trust each other?** — No trust chain
+
+ComputeID AgentID solves all of these with cryptographic guarantees.
+
+---
+
+## Free Tier
+
+| Feature | Free | Growth ($499/mo) | Enterprise ($1,999/mo) |
+|---------|------|------------------|------------------------|
+| Device passports | 3 devices | 50 devices | Unlimited |
+| Agent passports | 5 agents | 100 agents | Unlimited |
+| Audit log retention | 7 days | 90 days | 1 year |
+| Quantum-safe certs | ❌ | ✅ | ✅ |
+| Custom CA | ❌ | ❌ | ✅ |
+| API access | ✅ | ✅ | ✅ |
+
+**Get started free at [compute-id.com](https://compute-id.com)**
+
+---
+
+## Regulatory Compliance
+
+ComputeID helps you meet:
+
+- **EU AI Act** — requires audit trails for high-risk AI systems
+- **NIST AI RMF** — AI risk management framework
+- **SOC2 Type II** — compute infrastructure audit logs
+- **NSA CNSA 2.0** — post-quantum cryptography by 2030
+
+---
+
+## Contributing
+
+ComputeID SDK is open source under the MIT license.
+
+We welcome contributions — especially:
+- Client libraries for other languages (Go, Rust, Java)
+- Integration examples with popular AI frameworks
+- Protocol specification improvements
+
+```bash
+git clone https://github.com/trustedaicompute-ops/computeid-sdk
+cd computeid-sdk
+pip install -e ".[dev]"
+```
+
+---
+
+## Links
+
+- **Website:** [compute-id.com](https://compute-id.com)
+- **Dashboard:** [aicomputeid.com](https://aicomputeid.com)
+- **GitHub:** [github.com/trustedaicompute-ops](https://github.com/trustedaicompute-ops)
+- **Email:** hello@compute-id.com
+
+---
+
+## License
+
+MIT License — free to use, modify and distribute.
+
+Copyright 2026 ComputeID / TrustedAI Compute

computeid_sdk-1.0.0/computeid.py

@@ -0,0 +1,325 @@
+"""
+ComputeID SDK v1.0.0
+Cryptographic identity for AI compute and agentic AI systems.
+https://compute-id.com
+"""
+
+import hashlib
+import json
+import uuid
+import requests
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List, Any
+
+COMPUTEID_API = "https://api.aicomputeid.com"
+SDK_VERSION   = "1.0.0"
+
+class ComputeIDError(Exception): pass
+class AuthenticationError(ComputeIDError): pass
+class RegistrationError(ComputeIDError): pass
+class RevocationError(ComputeIDError): pass
+class TrustError(ComputeIDError): pass
+
+class AgentCapabilities:
+    def __init__(self, can_browse_web=False, can_execute_code=False,
+                 can_access_files=False, can_call_apis=True, can_spawn_agents=False,
+                 can_access_database=False, can_send_email=False,
+                 max_actions_per_hour=100, trust_level="restricted",
+                 human_in_loop=True, allowed_domains=None, allowed_tools=None,
+                 max_token_budget=None, custom_permissions=None, **kwargs):
+        self.can_browse_web       = can_browse_web
+        self.can_execute_code     = can_execute_code
+        self.can_access_files     = can_access_files
+        self.can_call_apis        = can_call_apis
+        self.can_spawn_agents     = can_spawn_agents
+        self.can_access_database  = can_access_database
+        self.can_send_email       = can_send_email
+        self.max_actions_per_hour = max_actions_per_hour
+        self.trust_level          = trust_level
+        self.human_in_loop        = human_in_loop
+        self.allowed_domains      = allowed_domains or []
+        self.allowed_tools        = allowed_tools or []
+        self.max_token_budget     = max_token_budget
+        self.custom_permissions   = custom_permissions or {}
+
+    def to_dict(self):
+        return self.__dict__
+
+    @classmethod
+    def restricted(cls):
+        return cls(trust_level="restricted", human_in_loop=True, max_actions_per_hour=50)
+
+    @classmethod
+    def standard(cls):
+        return cls(can_browse_web=True, can_call_apis=True, can_access_files=True,
+                   trust_level="standard", human_in_loop=True, max_actions_per_hour=200)
+
+    @classmethod
+    def elevated(cls):
+        return cls(can_browse_web=True, can_execute_code=True, can_call_apis=True,
+                   can_access_files=True, can_spawn_agents=True,
+                   trust_level="elevated", human_in_loop=False, max_actions_per_hour=1000)
+
+    @classmethod
+    def autonomous(cls):
+        return cls(can_browse_web=True, can_execute_code=True, can_call_apis=True,
+                   can_access_files=True, can_spawn_agents=True,
+                   can_access_database=True, can_send_email=True,
+                   trust_level="autonomous", human_in_loop=False, max_actions_per_hour=10000)
+
+
+class AgentPassport:
+    def __init__(self, data):
+        self.agent_id        = data.get("agent_id", str(uuid.uuid4()))
+        self.agent_name      = data.get("agent_name")
+        self.agent_type      = data.get("agent_type")
+        self.owner_org       = data.get("owner_org")
+        self.owner_email     = data.get("owner_email")
+        self.model           = data.get("model")
+        self.version         = data.get("version", "1.0.0")
+        self.status          = data.get("status", "active")
+        self.trust_level     = data.get("trust_level", "restricted")
+        self.parent_agent_id = data.get("parent_agent_id")
+        self.issued_at       = data.get("issued_at", datetime.utcnow().isoformat())
+        self.expires_at      = data.get("expires_at")
+        self.revoked_at      = data.get("revoked_at")
+        self.revoke_reason   = data.get("revoke_reason")
+        caps = data.get("capabilities", {})
+        self.capabilities    = AgentCapabilities(**caps) if isinstance(caps, dict) else caps
+        self._audit_log      = data.get("audit_log", [])
+        self._fingerprint    = hashlib.sha256(
+            f"{self.agent_id}{self.agent_name}{self.owner_org}{self.issued_at}".encode()
+        ).hexdigest()[:16]
+
+    @classmethod
+    def issue(cls, agent_name, agent_type, owner_org, owner_email,
+              capabilities, model="unknown", version="1.0.0",
+              parent_passport=None, expires_in_hours=24,
+              api_key=None, api_url=COMPUTEID_API):
+        if parent_passport:
+            if not parent_passport.capabilities.can_spawn_agents:
+                raise TrustError("Parent agent cannot spawn child agents")
+            if not parent_passport.is_trusted():
+                raise TrustError("Parent agent is not trusted")
+        now = datetime.utcnow()
+        data = {
+            "agent_id":        str(uuid.uuid4()),
+            "agent_name":      agent_name,
+            "agent_type":      agent_type,
+            "owner_org":       owner_org,
+            "owner_email":     owner_email,
+            "model":           model,
+            "version":         version,
+            "status":          "active",
+            "trust_level":     capabilities.trust_level,
+            "parent_agent_id": parent_passport.agent_id if parent_passport else None,
+            "issued_at":       now.isoformat(),
+            "expires_at":      (now + timedelta(hours=expires_in_hours)).isoformat(),
+            "capabilities":    capabilities.to_dict(),
+            "audit_log":       [],
+        }
+        passport = cls(data)
+        passport.log_action("passport_issued", {"agent_name": agent_name}, "success")
+        return passport
+
+    def log_action(self, action, details=None, outcome="success"):
+        entry = {
+            "log_id":    str(uuid.uuid4()),
+            "agent_id":  self.agent_id,
+            "action":    action,
+            "details":   details or {},
+            "outcome":   outcome,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+        self._audit_log.append(entry)
+        return entry
+
+    def verify_action(self, action):
+        if not self.is_trusted():
+            self.log_action(action, outcome="blocked", details={"reason": "passport_invalid"})
+            return False
+        action_map = {
+            "browse_web":      self.capabilities.can_browse_web,
+            "execute_code":    self.capabilities.can_execute_code,
+            "access_files":    self.capabilities.can_access_files,
+            "call_api":        self.capabilities.can_call_apis,
+            "spawn_agent":     self.capabilities.can_spawn_agents,
+            "access_database": self.capabilities.can_access_database,
+            "send_email":      self.capabilities.can_send_email,
+        }
+        allowed = action_map.get(action, False)
+        if not allowed:
+            self.log_action(action, outcome="blocked", details={"reason": "capability_not_granted"})
+        return allowed
+
+    def revoke(self, reason="Manual revocation"):
+        self.status        = "revoked"
+        self.revoked_at    = datetime.utcnow().isoformat()
+        self.revoke_reason = reason
+        self.log_action("passport_revoked", {"reason": reason}, "success")
+
+    def is_trusted(self):
+        if self.status != "active":
+            return False
+        if self.expires_at:
+            expires = datetime.fromisoformat(self.expires_at.replace("Z", ""))
+            if datetime.utcnow() > expires:
+                self.status = "expired"
+                return False
+        return True
+
+    def get_audit_log(self):
+        return self._audit_log.copy()
+
+    def get_summary(self):
+        return {
+            "agent_id":       self.agent_id,
+            "agent_name":     self.agent_name,
+            "owner_org":      self.owner_org,
+            "model":          self.model,
+            "status":         self.status,
+            "trust_level":    self.trust_level,
+            "issued_at":      self.issued_at,
+            "expires_at":     self.expires_at,
+            "actions_logged": len(self._audit_log),
+            "fingerprint":    self._fingerprint,
+        }
+
+    def export(self):
+        data = self.get_summary()
+        data["capabilities"] = self.capabilities.to_dict()
+        data["audit_log"]    = self._audit_log
+        return json.dumps(data, indent=2)
+
+    @classmethod
+    def load(cls, json_str):
+        return cls(json.loads(json_str))
+
+    def __repr__(self):
+        return f"<AgentPassport {self.agent_id[:8]}... | {self.agent_name} | {self.trust_level} | {self.status}>"
+
+
+class DevicePassport:
+    def __init__(self, data):
+        self.device_id   = data.get("device_id")
+        self.device_code = data.get("device_code")
+        self.name        = data.get("name")
+        self.device_type = data.get("type")
+        self.ip_address  = data.get("ip_address")
+        self.status      = data.get("status", "pending")
+        self.issued_at   = data.get("issued_at", datetime.utcnow().isoformat())
+
+    @classmethod
+    def register(cls, name, device_type, ip_address, api_key=None, api_url=COMPUTEID_API):
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        try:
+            res = requests.post(f"{api_url}/api/devices/register",
+                                json={"name": name, "type": device_type, "ip_address": ip_address},
+                                headers=headers, timeout=30)
+            data = res.json()
+            if not res.ok:
+                raise RegistrationError(data.get("error", "Registration failed"))
+            return cls(data)
+        except requests.RequestException as e:
+            raise RegistrationError(f"Network error: {e}")
+
+    @classmethod
+    def authenticate(cls, device_code, api_url=COMPUTEID_API):
+        try:
+            res = requests.post(f"{api_url}/api/devices/authenticate",
+                                json={"device_code": device_code},
+                                headers={"Content-Type": "application/json"}, timeout=30)
+            data = res.json()
+            if not res.ok:
+                raise AuthenticationError(data.get("error", "Authentication failed"))
+            return data.get("access_token")
+        except requests.RequestException as e:
+            raise AuthenticationError(f"Network error: {e}")
+
+    def is_valid(self):
+        return self.status == "active"
+
+    def __repr__(self):
+        return f"<DevicePassport {self.device_code} | {self.name} | {self.status}>"
+
+
+class TrustRegistry:
+    def __init__(self, org_name, api_key=None):
+        self.org_name  = org_name
+        self.api_key   = api_key
+        self._agents   = {}
+        self._devices  = {}
+
+    def register_agent(self, passport):
+        self._agents[passport.agent_id] = passport
+
+    def register_device(self, passport):
+        if passport.device_id:
+            self._devices[passport.device_id] = passport
+
+    def is_trusted(self, agent_id):
+        passport = self._agents.get(agent_id)
+        return passport.is_trusted() if passport else False
+
+    def revoke_agent(self, agent_id, reason="Revoked by registry"):
+        passport = self._agents.get(agent_id)
+        if passport:
+            passport.revoke(reason)
+            return True
+        return False
+
+    def get_active_agents(self):
+        return [p for p in self._agents.values() if p.is_trusted()]
+
+    def get_audit_report(self):
+        return {
+            "org_name":      self.org_name,
+            "generated_at":  datetime.utcnow().isoformat(),
+            "total_agents":  len(self._agents),
+            "active_agents": len(self.get_active_agents()),
+            "total_devices": len(self._devices),
+            "agents": [{**p.get_summary(), "audit_log": p.get_audit_log()}
+                       for p in self._agents.values()]
+        }
+
+    def __repr__(self):
+        return f"<TrustRegistry {self.org_name} | {len(self._agents)} agents>"
+
+
+def requires_passport(capability=None):
+    def decorator(func):
+        def wrapper(*args, passport=None, **kwargs):
+            if passport is None:
+                raise AuthenticationError(f"{func.__name__} requires an AgentPassport")
+            if not passport.is_trusted():
+                raise AuthenticationError(f"Passport for {passport.agent_name} is not trusted")
+            if capability and not passport.verify_action(capability):
+                raise TrustError(f"Agent lacks {capability} capability")
+            passport.log_action(func.__name__, outcome="success")
+            return func(*args, passport=passport, **kwargs)
+        wrapper.__name__ = func.__name__
+        return wrapper
+    return decorator
+
+
+def issue_agent_passport(agent_name, owner_org, owner_email,
+                          trust_level="standard", model="unknown", api_key=None):
+    caps_map = {
+        "restricted": AgentCapabilities.restricted(),
+        "standard":   AgentCapabilities.standard(),
+        "elevated":   AgentCapabilities.elevated(),
+        "autonomous": AgentCapabilities.autonomous(),
+    }
+    return AgentPassport.issue(
+        agent_name=agent_name, agent_type="general",
+        owner_org=owner_org, owner_email=owner_email,
+        capabilities=caps_map.get(trust_level, AgentCapabilities.standard()),
+        model=model, api_key=api_key
+    )
+
+
+def register_gpu(name, ip_address, api_key=None):
+    return DevicePassport.register(name=name, device_type="GPU",
+                                   ip_address=ip_address, api_key=api_key)

computeid_sdk-1.0.0/computeid_sdk.egg-info/PKG-INFO

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: computeid-sdk
+Version: 1.0.0
+Summary: Cryptographic identity for AI compute infrastructure and agentic AI systems
+Home-page: https://github.com/trustedaicompute-ops/computeid-sdk
+Author: ComputeID
+Author-email: hello@compute-id.com
+Keywords: gpu identity certificates quantum-safe ai agents security cryptography
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ComputeID SDK
+
+**Cryptographic identity for AI compute infrastructure and agentic AI systems.**
+
+> Every GPU needs a passport. Every AI agent needs an identity.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.0.0-blue)](https://pypi.org/project/computeid-sdk/)
+[![compute-id.com](https://img.shields.io/badge/docs-compute--id.com-00b4ff)](https://compute-id.com)
+
+---
+
+## What is ComputeID?
+
+ComputeID provides two things:
+
+1. **DeviceID** — Cryptographic passports for GPUs, servers, and compute hardware
+2. **AgentID** — Cryptographic passports for AI agents and autonomous systems
+
+Think of it as a passport system for AI infrastructure. Every device and every agent gets a unique cryptographic identity, a certificate of what it is allowed to do, and an immutable audit trail of everything it has done.
+
+---
+
+## Installation
+
+```bash
+pip install computeid-sdk
+```
+
+---
+
+## Quick Start
+
+### GPU / Device Identity
+
+```python
+from computeid import register_gpu
+
+# Register a GPU and get a cryptographic passport
+passport = register_gpu(
+    name="NVIDIA A100 #1",
+    ip_address="192.168.1.10",
+    api_key="your-api-key"  # optional for free tier
+)
+
+print(passport.device_code)  # GPU-001
+print(passport.is_valid())   # True
+```
+
+### AI Agent Identity
+
+```python
+from computeid import issue_agent_passport
+
+# Issue a passport for your AI agent
+passport = issue_agent_passport(
+    agent_name="ResearchAgent",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    trust_level="standard",
+    model="claude-sonnet-4-5"
+)
+
+# Check if trusted before giving access
+if passport.is_trusted():
+    run_your_agent(passport=passport)
+
+# Log every action the agent takes
+passport.log_action("web_search", {"query": "market research"}, "success")
+
+# Revoke instantly if needed
+passport.revoke(reason="Unexpected behaviour detected")
+```
+
+---
+
+## Agent Trust Levels
+
+| Level | Description | Use Case |
+|-------|-------------|----------|
+| `restricted` | Read only, human oversight required | Testing, low-risk tasks |
+| `standard` | Web browsing, API calls, file read | Most production agents |
+| `elevated` | Code execution, spawn child agents | Advanced automation |
+| `autonomous` | Full autonomy | Mission-critical systems |
+
+---
+
+## Full Example — Agentic AI with PassportSystem
+
+```python
+from computeid import (
+    AgentPassport,
+    AgentCapabilities,
+    TrustRegistry,
+    requires_passport
+)
+
+# 1. Create capabilities for your agent
+caps = AgentCapabilities(
+    can_browse_web=True,
+    can_call_apis=True,
+    can_execute_code=False,   # not allowed
+    trust_level="standard",
+    human_in_loop=True,
+    max_actions_per_hour=100
+)
+
+# 2. Issue a passport
+passport = AgentPassport.issue(
+    agent_name="DataAnalysisAgent",
+    agent_type="analyst",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=caps,
+    model="claude-sonnet-4-5",
+    version="2.1.0"
+)
+
+# 3. Protect your functions with passport checks
+@requires_passport(capability="browse_web")
+def search_web(query: str, passport: AgentPassport):
+    # This function can only be called by agents
+    # with a valid passport that has browse_web capability
+    results = do_search(query)
+    return results
+
+# 4. Call protected function
+results = search_web("GPU rental prices", passport=passport)
+
+# 5. View the audit trail
+for entry in passport.get_audit_log():
+    print(f"{entry['timestamp']} | {entry['action']} | {entry['outcome']}")
+
+# 6. Multi-agent trust chain
+orchestrator = AgentPassport.issue(
+    agent_name="OrchestratorAgent",
+    agent_type="orchestrator",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.elevated(),
+    model="claude-opus-4-6"
+)
+
+# Spawn a child agent — only works if orchestrator has can_spawn_agents=True
+child_agent = AgentPassport.issue(
+    agent_name="SubAgent-1",
+    agent_type="worker",
+    owner_org="Acme Corp",
+    owner_email="admin@acme.com",
+    capabilities=AgentCapabilities.standard(),
+    model="claude-sonnet-4-5",
+    parent_passport=orchestrator   # establishes trust chain
+)
+
+# 7. Organisation-wide trust registry
+registry = TrustRegistry(org_name="Acme Corp")
+registry.register_agent(orchestrator)
+registry.register_agent(child_agent)
+
+# Check trust
+if registry.is_trusted(child_agent.agent_id):
+    print("Agent is trusted")
+
+# Get full audit report
+report = registry.get_audit_report()
+print(f"Total agents: {report['total_agents']}")
+print(f"Active agents: {report['active_agents']}")
+```
+
+---
+
+## Why Agent Passports Matter
+
+The rise of agentic AI creates a new security challenge:
+
+- **Who built this agent?** — No way to verify
+- **What is it allowed to do?** — No standard capability model
+- **What has it done?** — No audit trail
+- **Can we stop it?** — No revocation mechanism
+- **Which agents trust each other?** — No trust chain
+
+ComputeID AgentID solves all of these with cryptographic guarantees.
+
+---
+
+## Free Tier
+
+| Feature | Free | Growth ($499/mo) | Enterprise ($1,999/mo) |
+|---------|------|------------------|------------------------|
+| Device passports | 3 devices | 50 devices | Unlimited |
+| Agent passports | 5 agents | 100 agents | Unlimited |
+| Audit log retention | 7 days | 90 days | 1 year |
+| Quantum-safe certs | ❌ | ✅ | ✅ |
+| Custom CA | ❌ | ❌ | ✅ |
+| API access | ✅ | ✅ | ✅ |
+
+**Get started free at [compute-id.com](https://compute-id.com)**
+
+---
+
+## Regulatory Compliance
+
+ComputeID helps you meet:
+
+- **EU AI Act** — requires audit trails for high-risk AI systems
+- **NIST AI RMF** — AI risk management framework
+- **SOC2 Type II** — compute infrastructure audit logs
+- **NSA CNSA 2.0** — post-quantum cryptography by 2030
+
+---
+
+## Contributing
+
+ComputeID SDK is open source under the MIT license.
+
+We welcome contributions — especially:
+- Client libraries for other languages (Go, Rust, Java)
+- Integration examples with popular AI frameworks
+- Protocol specification improvements
+
+```bash
+git clone https://github.com/trustedaicompute-ops/computeid-sdk
+cd computeid-sdk
+pip install -e ".[dev]"
+```
+
+---
+
+## Links
+
+- **Website:** [compute-id.com](https://compute-id.com)
+- **Dashboard:** [aicomputeid.com](https://aicomputeid.com)
+- **GitHub:** [github.com/trustedaicompute-ops](https://github.com/trustedaicompute-ops)
+- **Email:** hello@compute-id.com
+
+---
+
+## License
+
+MIT License — free to use, modify and distribute.
+
+Copyright 2026 ComputeID / TrustedAI Compute

computeid_sdk-1.0.0/computeid_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+computeid.py
+setup.py
+computeid_sdk.egg-info/PKG-INFO
+computeid_sdk.egg-info/SOURCES.txt
+computeid_sdk.egg-info/dependency_links.txt
+computeid_sdk.egg-info/requires.txt
+computeid_sdk.egg-info/top_level.txt

computeid_sdk-1.0.0/computeid_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

computeid_sdk-1.0.0/computeid_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

computeid_sdk-1.0.0/computeid_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+computeid

computeid_sdk-1.0.0/setup.cfg

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

computeid_sdk-1.0.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="computeid-sdk",
+    version="1.0.0",
+    description="Cryptographic identity for AI compute infrastructure and agentic AI systems",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="ComputeID",
+    author_email="hello@compute-id.com",
+    url="https://github.com/trustedaicompute-ops/computeid-sdk",
+    py_modules=["computeid"],
+    install_requires=["requests>=2.28.0"],
+    python_requires=">=3.8",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Topic :: Security :: Cryptography",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    keywords="gpu identity certificates quantum-safe ai agents security cryptography",
+)