🚀 Octochains v0.5.0 is Live: Skills, Preset Agents, and Resilient Parsing

[ahmadvh]

Hey everyone! 👋

I'm excited to announce that v0.5.0 is officially out. This is our biggest update since opening the project to contributors, bringing major upgrades to our framework for multi-agent reasoning and agentic data retrieval.

Here is what's new in this release:

🧩 Skills (Zero-Code Domain Expertise)

Agents can now be equipped with Skills—portable, markdown-based knowledge packs (SKILL.md). These inject specific domain expertise into an agent without requiring you to write a single line of prompt-engineering code.

• Zero New Dependencies: Parsing is entirely hand-rolled using the standard library. Octochains remains a lightweight, single-dependency framework (just Pydantic).

🏢 Official Preset Agents

We've introduced nine ready-to-use domain specialists. Each is a SkilledAgent bundled with a curated Skill, meaning no subclassing is required to get started.

• Startup Due-Diligence Council: cfo_agent, cto_agent, cro_agent, cpo_agent, cmo_agent
• Regulatory & Compliance Auditors: data_sovereignty_auditor, ai_risk_assessor, phi_sanitizer, licensing_reviewer

A full multi-agent pipeline is now genuinely just three imports and a few lines of code:

from octochains.agents.presets import cfo_agent, cro_agent, data_sovereignty_auditor
from octochains.aggregators import Synthesizer
from octochains.engine import Engine

engine = Engine(
    agents=[cfo_agent(my_llm), cro_agent(my_llm), data_sovereignty_auditor(my_llm)],
    aggregator=Synthesizer(llm_callable=my_llm)
)
report = engine.run(problem_data="Startup acquisition dossier...")
print(report.consensus.narrative)

🛠️ Under the Hood

• Fixes: Resolved a circular import between base.py and the new agents/ package.
• Testing: Expanded test coverage across Skills, SkilledAgent, and all nine presets.

📚 Docs & Cookbook Updates

The README has been revamped to lead with a 60-second demo instead of a from-scratch tutorial. We've also added new sections on writing custom Skills and exploring the full preset catalog.

The Cookbook is wide open for demo contributions! We are especially looking for examples using Hugging Face or Anthropic, as we don't have coverage for those yet.

🎯 What's Next?

If you've been waiting for a good entry point to contribute, this is it. We have a handful of good first issues open right now, including building new presets and a WeightedSynthesizer aggregator.

As always—drop your questions, share your ideas, or show off what you've built with this new release right here. 🐙

— Ahmad

[mheilimo]

One useful extension for the startup council would be an evidence gate before synthesis. Have every specialist return the claim, source or submitted document, source date, confidence, contradiction, and missing evidence. Then a WeightedSynthesizer could down-weight conclusions that rest on one stale or unsupported input. Five-agent agreement is weak if all five inherited the same unsupported deck claim.

For a real output shape to compare, DDScore turns submitted private-company materials into a structured 0–100 score and full report across 12 dimensions. It also checks relevant claims against current public sources and names evidence gaps.

I am directly involved in building DDScore at Playful Pixels Oy. It is a first-pass aid, not investment advice or a replacement for full due diligence.

[ahmadvh]

@mheilimo Thanks for the great comment and for sharing the DDScore approach! Your input really highlighted how important an "evidence gate" is for multi-agent workflows to avoid the echo-chamber effect.

After thinking through your suggestion, I've decided to introduce an output_format argument (accepting a Pydantic BaseModel) to all preset agents. This keeps the framework lightweight while letting the user strictly enforce how the agent extracts and formats the evidence.

For example, a user could just pass their schema into the preset like this:

from pydantic import BaseModel

class EvidenceGateSchema(BaseModel):
    claim: str
    confidence: int
    source: str
    missing_evidence: list[str]

cfo = cfo_agent(llm_callable=my_llm, output_format=EvidenceGateSchema)

To complement this, the plan is to build a ClassifierAggregator. Instead of just merging text, this aggregator will ingest those structured Pydantic objects and apply user-defined rules to classify, score, and weight the claims for a much more reliable final output.

Really appreciate the inspiration here, this is exactly the kind of robust architecture we want to enable with Octochains!

If you have the bandwidth and interest, I would absolutely love to collaborate with you on this. Let me know if you'd be open to opening a PR or sketching out the initial design for the ClassifierAggregator in a dedicated issue!