Introducing ORCA: executable skills and capabilities for AI agent workflows

The problem

Most agent frameworks are great at orchestrating LLM calls. But when it comes to deterministic operations — parsing documents, validating schemas, deduplicating records — you end up writing custom glue code every time.

I wanted a framework where agents could actually execute, not just plan.

What is ORCA?

ORCA (Open Runtime for Capable Agents) is an open-source Python framework that treats agent actions as capabilities — declarative YAML contracts that can be wired to any backend: pure Python, OpenAI, or external APIs.

You compose capabilities into skills (multi-step workflows defined as DAGs), and the runtime handles scheduling, policy enforcement, and state tracking.

What's included

• 122 capabilities with deterministic Python baselines — no API keys needed
• 36 ready-to-use skills composed from those capabilities
• DAG scheduler with policy gates and cognitive state tracking
• Scaffold wizard to build new skills in minutes
• Auto-bindings for OpenAI and PythonCall out of the box
• Adapters for LangChain, CrewAI, and Semantic Kernel
• MCP server support

Quick example

A capability is a YAML contract:

yaml
id: doc.content.chunk
description: Split a document into semantic chunks
input:
  content: { type: string }
  max_tokens: { type: integer, default: 512 }
output:
  chunks: { type: array, items: { type: string } }


A skill composes multiple capabilities as a DAG:

id: document.summarize
steps:
  - id: chunk
    capability: doc.content.chunk
  - id: summarize
    capability: text.body.summarize
    depends_on: [chunk]
  - id: compile
    capability: text.report.compile
    depends_on: [summarize]


The scheduler resolves dependencies, runs steps in parallel when possible, and enforces policies at each gate.

Why not just use LangChain / CrewAI directly?
You can — ORCA has adapters for both. The difference is in the abstraction layer:

      **Traditional frameworks  ORCA**
Actions         Code functions          Declarative YAML capabilities
Composition Imperative chains   DAG-based skills
Execution   LLM-dependent           Det. baselines + LLM fallback
Portability Framework-locked    Bind to any backend

ORCA doesn't replace your orchestration framework — it gives your agents a portable, testable skill layer underneath.

Getting started
pip install agent-skills

from agent_skills import Registry

registry = Registry()
result = registry.execute("doc.content.chunk", {
    "content": "Your document text here...",
    "max_tokens": 256
})
print(result["chunks"])

Links
GitHub: github.com/gfernandf/agent-skills
Documentation: gfernandf.github.io/agent-skills
Registry: github.com/gfernandf/agent-skill-registry
Feedback welcome
The project is early — just made the repos public this week. I'd appreciate feedback on the design, missing capabilities, or anything that feels rough.

Drop a comment here or open an issue on GitHub — happy to discuss.