Home/Projects/Abel
Prototype
AI AgentsLLM InfrastructureDeveloper Tools

Abel

Naive prompt chaining is opaque by design: state lives in strings, control flow is implicit, and debugging requires replaying the entire chain. Abel replaces this with a typed execution graph where each agent node declares its input schema, output schema, prompt template, and fallback policy — making pipelines inspectable at every step.

recruiter perspective

Built a production-grade AI agent framework from scratch

  • ›Designed a typed execution graph for multi-step LLM workflows
  • ›Supports OpenAI, Anthropic, and local models via a unified adapter pattern
  • ›Makes AI pipelines debuggable, auditable, and testable — not just functional
Read the architecture
Hiring Summary

Abel is an AI agent framework I built to solve the debuggability problem in multi-step LLM pipelines. Instead of prompt chains, it uses a typed execution graph where each step declares its inputs, outputs, and fallback logic. It supports OpenAI, Anthropic, and local Ollama via a unified adapter, and has been used to build document-analysis and research-automation workflows. The core problem it solves: making AI pipelines auditable, not just functional.

Each claim is paired with evidence that a recruiter can request or verify.

“Abel's typed DAG makes agent state inspectable at every step, eliminating the need to replay full pipelines to debug a single node failure.”
diagramAgent Execution Graph● coming soon✓
repoCore Engine Source● coming soon✓
engineerai
“A unified adapter interface makes switching between OpenAI, Anthropic, and local Ollama a one-line config change — no node rewrites required.”
writeupAdapter Interface Design Doc● coming soon✓
engineerairecruiter
“Explicit fallback nodes with access to the full error payload enable graceful degradation without ad-hoc try/except logic scattered across the pipeline.”
repoCore Engine Source● coming soon✓
engineer

Metrics marked with context indicate the measurement scope (local benchmark, prototype, qualitative estimate, etc.).

12
node types
Node Types Implemented
Tool, retrieval, synthesis, decision, loop, fork, join, guard, map, filter, cache, validator
3
providers
LLM Backends Supported
OpenAI, Anthropic, local Ollama — via unified adapter (local benchmark)
100%
immutable context
State Isolation
Each node receives a read-only context dict; state mutations are tracked as delta objects (architectural property)

LLM pipelines built with naive prompt chaining are opaque, hard to debug, and brittle across provider updates. When a chain fails at step 7 of 12, there's no clean way to inspect what state step 6 emitted, replay just that segment, or swap in a fallback. The problem compounds in production where engineers need auditability, not just functionality.

Challenges Addressed
  • Must work with multiple LLM providers without rewriting pipeline logic
  • Agent state must be inspectable and loggable at each step without manual instrumentation
  • Must support conditional branching, parallel execution, and per-node retry/fallback policies
  • Node schemas must be statically typed and validated at runtime
⬡AbelAI AGENTS/visual-placeholder

Abel models a pipeline as a typed DAG. Each AgentNode declares: an input Pydantic model, a prompt template with variable interpolation, an output Pydantic model, an optional retry policy (max attempts, backoff), and an optional fallback node ID. A central GraphExecutor performs topological sort, walks the DAG, maintains an immutable context object, and emits structured logs per node. Fork/join nodes enable parallel branches. Redis is used for distributed state in multi-worker deployments.

Stack
PythonTypeScriptOpenAI APIAnthropic APIPydanticFastAPIRedis
Decision
Use a typed graph over linear chains
Chains hide control flow. A graph makes branching, merging, and parallelism explicit, testable, and visualizable. It also enables partial re-execution: replay from any node without re-running the full pipeline.
Decision
Separate adapter layer for LLM providers
Provider APIs differ significantly in request shape, streaming behavior, and error formats. A unified interface (`async complete(messages, schema) -> schema`) fully encapsulates these differences, future-proofing nodes against provider churn.
Decision
Immutable context dict between nodes
Mutable shared state causes subtle bugs in parallel branches and makes replay impossible. Immutability enforces that each node's output is its only contribution to downstream state.
Tradeoff
Graph verbosity vs. implicit chaining
Chose: Explicit graph definition
Debuggability and testability outweigh setup ergonomics for production pipelines. A more ergonomic builder API can be layered on top without sacrificing the underlying guarantees.
Tradeoff
Runtime schema validation cost vs. safety
Chose: Validate every node boundary
LLM outputs are unpredictable. Catching schema violations at node boundaries prevents corrupt state from propagating silently through downstream nodes.
01Visual graph editor: drag-and-drop pipeline builder that outputs Abel config
02Distributed execution with work-stealing queue across multiple workers
03Native vector store integration for retrieval nodes
04Graph diff tool: compare two pipeline versions structurally, not textually