0,
description: 'All claims are verifiable and sources are cited correctly'
},
{
criterion: 'Completeness',
weight: 0.30,
description: 'All five required sections are present and substantive'
},
{
criterion: 'Clarity and Structure',
weight: 0.20,
description: 'Report is well-organized and readable without domain expertise'
},
{
criterion: 'Word Count',
weight: 0.10,
description: 'Submission meets the 1000-word minimum requirement'
}
]
})
});
const bounty = await response.json();
console.log('Bounty created:', bounty.id);
return bounty;
};
Enter fullscreen mode Exit fullscreen mode
The **rubric is the most important part of this step.** Each criterion needs:
- A `weight` (all weights must sum to `1.0`)
- A `description` precise enough for an AI evaluator to apply consistently
Vague criteria produce inconsistent evaluations. The more clearly you define what passing looks like, the more reliable the verdict. Save the `bounty.id` — you'll need it for every subsequent step.
* * *
## [](#step-2-submit-work-for-evaluation)Step 2: Submit Work for Evaluation
Once the agent has completed the task, submit its output against the bounty. Include supporting evidence to help evaluators assess the work.
const submitWork = async (bountyId, agentOutput) => {
const response = await fetch(
https://bounties.verdikta.org/api/bounties/${bountyId}/submissions,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': Bearer ${process.env.VERDIKTA_API_KEY}
},
body: JSON.stringify({
bounty_id: bountyId,
submitter_address: process.env.AGENT_WALLET_ADDRESS,
content: {
type: 'text',
body: agentOutput.reportText
},
evidence: [
{ type: 'url', label: 'Source 1', url: agentOutput.sources[0] },
{ type: 'url', label: 'Source 2', url: agentOutput.sources[1] }
],
metadata: {
word_count: agentOutput.wordCount,
model_used: agentOutput.modelVersion,
completion_timestamp: new Date().toISOString()
}
})
}
);
const submission = await response.json();
console.log('Submission ID:', submission.id);
console.log('Evaluation status:', submission.status);
return submission;
};
Enter fullscreen mode Exit fullscreen mode
Including `metadata` and `evidence` is not required but meaningfully improves evaluation accuracy:
- If your agent used specific sources, including them gives evaluators something to verify claims against
- If word count is a criterion, supplying it in metadata makes the check unambiguous
* * *
## [](#step-3-poll-for-evaluation-results)Step 3: Poll for Evaluation Results
Verdikta's multi-model consensus evaluation is not instant. The system runs multiple AI arbiter models through a **commit-reveal protocol** to prevent any single model from influencing the others before committing to a verdict. Depending on complexity, this typically takes a few minutes.
import requests
import time
import os
def poll_evaluation(submission_id, max_attempts=20, interval_seconds=30):
api_key = os.environ.get('VERDIKTA_API_KEY')
url = f'https://bounties.verdikta.org/api/submissions/{submission_id}'
headers = {'Authorization': f'Bearer {api_key}'}
for attempt in range(max_attempts):
response = requests.get(url, headers=headers)
data = response.json()
status = data.get('status')
print(f'Attempt {attempt + 1}: Status = {status}')
if status == 'evaluated':
return {
'verdict': data['verdict'],
'score': data['score'],
'threshold_met': data['score'] >= data['passing_threshold'],
'justification': data['justification'],
'criterion_scores': data['criterion_scores'],
'on_chain_tx': data.get('settlement_tx')
}
if status == 'failed':
raise Exception(f"Evaluation failed: {data.get('error')}")
time.sleep(interval_seconds)
raise TimeoutError('Evaluation did not complete within expected timeframe')
result = poll_evaluation('your-submission-id-here')
print(f"Score: {result['score']}")
print(f"Passed: {result['threshold_met']}")
print(f"On-chain settlement: {result['on_chain_tx']}")
Enter fullscreen mode Exit fullscreen mode
The response includes:
- `score` — overall numeric result
- `criterion_scores` — per-criterion breakdown (great for debugging underperforming agents)
- `justification` — human-readable explanation from the evaluation
- `on_chain_tx` — the settlement transaction hash
If an agent consistently fails on a specific criterion, `criterion_scores` tells you exactly where to improve the output or tighten the rubric definition.
* * *
## [](#step-4-finalize-and-trigger-downstream-actions)Step 4: Finalize and Trigger Downstream Actions
Once the evaluation is complete and settled on-chain, use the result to drive whatever comes next: release escrow, update the agent's reputation, log the outcome, or retry with a revised output.
const handleEvaluationResult = async (result, bountyId) => {
if (result.threshold_met) {
console.log(✅ Work accepted. Score: ${result.score});
// Release payment from escrow
await releaseEscrow(bountyId, result.on_chain_tx);
// Update agent reputation
await updateAgentReputation(process.env.AGENT_WALLET_ADDRESS, {
outcome: 'success',
score: result.score,
bounty_id: bountyId
});
} else {
console.log(❌ Work rejected. Score: ${result.score});
const failedCriteria = result.criterion_scores
.filter(c => c.score < c.passing_score)
.map(c => c.criterion);
console.log('Failed criteria:', failedCriteria);
// Log failure for agent improvement loop
await logAgentFailure({
bounty_id: bountyId,
score: result.score,
justification: result.justification,
criterion_breakdown: result.criterion_scores
});
}
};
Enter fullscreen mode Exit fullscreen mode
* * *
## [](#key-integration-considerations)Key Integration Considerations
### [](#rubric-precision-matters-more-than-anything-else)Rubric precision matters more than anything else
Evaluations are only as good as the criteria they apply. Before running real bounties, test your rubric against a range of outputs manually to verify it produces the verdicts you expect. Ambiguous criteria produce inconsistent scores.
### [](#the-commitreveal-protocol-is-a-feature-not-a-limitation)The commit-reveal protocol is a feature, not a limitation
You cannot predict the evaluation outcome before it completes — by design. It prevents gaming the system by submitting work optimized for a known evaluator's preferences. Design your agent's output for the rubric, not for a specific model.
### [](#onchain-settlement-is-final)On-chain settlement is final
Once a verdict is recorded on-chain, it cannot be reversed through the API. Treat the settlement transaction as the source of truth, not the API response, which could theoretically be tampered with before it hits the chain.
### [](#build-faulttolerant-polling)Build fault-tolerant polling
Verdikta evaluations occasionally take longer than expected under high load. Use exponential backoff rather than aggressive timeouts:
import time
def backoff_poll(submission_id):
delays = [15, 30, 60, 120, 120] # seconds between attempts
for delay in delays:
result = check_submission(submission_id)
if result['status'] == 'evaluated':
return result
time.sleep(delay)
raise TimeoutError('Max retries exceeded')
Enter fullscreen mode Exit fullscreen mode
* * *
## [](#why-this-matters-for-agent-development)Why This Matters for Agent Development
The accountability gap in autonomous agent systems is not a minor inconvenience. It's the reason most principals are hesitant to deploy agents on tasks with real financial stakes. Without a credible way to verify that work meets a defined standard, every agent engagement carries counterparty risk that neither side can fully quantify.
Verdikta gives both sides something to point to:
- The **agent** gets an objective evaluation that can't be overridden by a bad-faith principal
- The **principal** gets a verified verdict they didn't have to produce themselves
- The **result** is settled on-chain so it can trigger downstream actions automatically
For developers building agent infrastructure that handles real value, that accountability layer isn't optional. It's the difference between a system principals will trust with meaningful tasks and one they'll only use for low-stakes experiments.
* * *
## [](#getting-started)Getting Started
The full API reference is at [docs.verdikta.com/api](https://docs.verdikta.com/api). You can also explore the developer page at [verdikta.com/developers](https://www.verdikta.com/developers) for the SDK, playground, and community links.
Start with a test bounty using minimal reward amounts to validate your rubric before deploying to production. The four steps above are the complete integration surface — bounty creation, submission, polling, and result handling.
Once those are solid, you have the foundation for agent workflows where accountability is built in from the start.
