###########################
_ _ _______ _
/ \ | |/ /_ _|/ \
/ _ \ | ' / | | / _ \
/ ___ \| . \ | |/ ___ \
/_/ \_\_|\_\ |_/_/ \_\
###########################
Open Scientific Action Protocol
Open protocol for deciding when AI-generated scientific outputs are admissible to shape what science does next
AI-for-science systems are moving from reasoning to action. They summarize literature, interpret evidence, draft protocols, recommend experiments, call lab tools, and prepare execution-adjacent workflows. The hard question is no longer whether the model can produce an output — it is whether that output should be allowed to change what science does next.
Most stacks treat this as a model-quality or prompt-engineering problem. AKTA treats it as a governance boundary: classify the proposed action, evaluate the evidence behind it, apply deployment policy, gate requested tools, and emit a durable record of the decision. Integrators can wire that boundary into evidence pipelines, human review, runtime proof, and release packaging without pretending the model alone is sufficient.
If AI changes what science does next, there should be an AKTA Record.
AKTA is a reference implementation of that protocol — not a safety certification, not a substitute for institutional review, and not a guarantee of scientific correctness.
flowchart LR
subgraph inputs["Inputs"]
AI[AI output]
Tool[Requested tool]
Ctx[Context / evidence report]
Policy[Policy bundle]
Overlay[Domain overlay]
end
inputs --> Gate[AKTA Gate]
Gate --> Decision[AKTA Decision]
Decision --> Record[AKTA Record]
Decision --> Review[SCOPE review trigger]
Decision --> PF[PF-Core obligation]
Record --> PCS[PCS artifact bundle]
Gate --> Runtime[Runtime tool enforcement]
Review --> Grant[Scoped grant]
Grant --> Gate
The gate classifies what the AI is trying to do, checks evidence and deployment policy, resolves the tool registry, and returns the strictest admissibility outcome. Blocked decisions include constructive next_admissible_steps. When human review authorizes a narrower scope, AKTA re-evaluates with that grant — it never broadens authorization on its own, and review grants do not override weak-evidence or profile policy by default. See authority transfer.
Install the reference kernel (Python 3.10+):
git clone https://github.com/fraware/AKTA.git
cd AKTA
pip install -e ".[dev]"Run the canonical weak-evidence block example — preliminary signal, mutating lab tool, decision blocked:
akta gate \
--output examples/weak_evidence/ai_output.json \
--tool lab_scheduler.prioritize \
--profile P2_analysis_assistant \
--context examples/weak_evidence/context.json \
--out examples/weak_evidence/akta_decision.jsonExpected outcome (abbreviated):
{
"admissibility": "blocked",
"decision_reason": "Evidence E2_preliminary_signal ... exceeds limit for resource prioritization.",
"blocked_tools": ["lab_scheduler.prioritize", "robot_queue.submit", "..."],
"next_admissible_steps": [
"downgrade to hypothesis discussion",
"draft a validation experiment",
"request domain review before prioritization",
"gather additional evidence"
],
"record_required": true
}Generate the durable record from the decision:
akta record \
--decision examples/weak_evidence/akta_decision.json \
--out examples/weak_evidence/akta_record.jsonFor the full integrated chain (evidence import through packaging), see examples/integrated_weak_evidence and python scripts/demo_integrated_weak_evidence.py.
Every gate evaluation produces structured artifacts you can store, audit, and hand to downstream systems:
| Output | What it is |
|---|---|
| AKTA Decision | Admissibility verdict, blocked/allowed tools, rationale, and constructive next steps |
| AKTA Record | Durable, hash-linked record suitable for provenance and replay |
| Review trigger | Packet for human review when authorization or domain review is required |
| PF-Core obligation | Runtime proof obligation describing what must be demonstrated before execution |
| PCS bundle | Versioned artifact bundle for release and cross-system verification |
REST API, MCP server, and batch evaluation are available for integrators — see Integration guide and OpenAPI spec.
| System | Role in the AKTA stack | Learn more |
|---|---|---|
| VSA | Imports structured evidence reports into AKTA context | VSA import |
| SCOPE | Human review and scoped authorization after a trigger | SCOPE bridge · Live conformance |
| PF-Core | Runtime proof obligations tied to admissibility decisions | PF-Core bridge |
| PCS | Packages decisions, records, and hashes for release verification | PCS export |
SCOPE connects in several modes — offline simulation (default), Python import from a sibling checkout, subprocess CLI, or a one-shot review command. Details and conformance checks: scope_live_conformance.md.
Cross-repo environment variables for optional CI jobs: .github/CROSS_REPO_CI.md.
We welcome contributions that sharpen the admissibility boundary — scenarios, domain overlays, adapters, docs, and tests. You do not need to be a policy expert to improve examples, fix edge cases, or extend integration paths.
Set up a dev environment:
pip install -e ".[dev,security]"
make cimake ci runs the full local check suite (tests, policy validation, scenario evals). Run pytest tests/ -v for a faster loop while iterating.
Good places to start:
| Area | Where to look |
|---|---|
| Scenarios and evals | scenarios/, evals/, tests/ |
| Domain overlays | overlays/, domain overlay guide |
| Adapters (VSA, SCOPE, PF, PCS, REST, MCP) | adapters/ |
| Documentation | docs/ — especially integration guide and scientific action admissibility |
Read CONTRIBUTING.md for pull-request expectations, GOVERNANCE.md for protocol stewardship, and docs/RELEASE.md for release verification. Be respectful, precise, and evidence-oriented — AKTA governs claim-to-action transitions, and contributions should preserve that boundary.
- Scientific action admissibility — protocol overview
- Field thesis — problem framing
- Integration guide — wiring AKTA into your stack
- AKTA Card guide — institutional disclosure artifact
- Review integration
- SCOPE bridge · Live SCOPE conformance
- PF-Core bridge · PCS export · VSA import
- AKTA v0.3 integration summary
- Policy integrity · Domain overlay guide
- Trusted boundary · Threat model
- Authority transfer · Limitations
- Security policy
- Scenario labeling guidelines
- Holdout private governance
- Version history and release criteria: CHANGELOG.md · docs/RELEASE.md
v0.7.1 (akta-protocol) is the current reference kernel. It implements the full admissibility loop — gate, record, review triggers, grant re-gating, PF export, and PCS packaging — with 385+ tests and a green make ci suite. Biology, chemistry, and clinical domain overlays are experimental and not deployment-ready without institutional governance. Fully autonomous scientific operator profiles are defined for taxonomy only and are not supported at runtime. AKTA is a reference implementation under the MIT license, not a safety certification. Known gaps and non-goals: docs/limitations.md.
MIT — see LICENSE.