{"id":49550121,"url":"https://github.com/yasik/agentlane","last_synced_at":"2026-05-02T22:03:40.055Z","repository":{"id":347435994,"uuid":"1173840097","full_name":"yasik/agentlane","owner":"yasik","description":"An event-based runtime and messaging framework for AI agents.","archived":false,"fork":false,"pushed_at":"2026-04-25T03:26:11.000Z","size":1483,"stargazers_count":3,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-04-25T05:25:31.475Z","etag":null,"topics":["agents","ai","ai-agents","anthropic","framework","llm","multiagent","open-source","openai","python"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/yasik.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-03-05T20:04:59.000Z","updated_at":"2026-04-25T03:26:17.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/yasik/agentlane","commit_stats":null,"previous_names":["yasik/agentlane"],"tags_count":6,"template":false,"template_full_name":null,"purl":"pkg:github/yasik/agentlane","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/yasik%2Fagentlane","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/yasik%2Fagentlane/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/yasik%2Fagentlane/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/yasik%2Fagentlane/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/yasik","download_url":"https://codeload.github.com/yasik/agentlane/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/yasik%2Fagentlane/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32550918,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-02T21:31:48.061Z","status":"ssl_error","status_checked_at":"2026-05-02T21:31:46.574Z","response_time":132,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agents","ai","ai-agents","anthropic","framework","llm","multiagent","open-source","openai","python"],"created_at":"2026-05-02T22:03:37.059Z","updated_at":"2026-05-02T22:03:40.039Z","avatar_url":"https://github.com/yasik.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# AgentLane\n\n**AgentLane is a runtime-first orchestration layer for building reliable, inspectable, production AI agents and workflows workflows.**\n\nIt is designed for systems where agent behavior needs to be explicit, structured, testable, and operable — especially in serious domains like healthcare where opaque prompt chains and autonomous demo loops are not enough.\n\nAgentLane helps you turn fragile prompt/tool chains into workflows with clear runtime boundaries: long-lived agents, addressed messaging, structured model interactions, tool execution, handoffs, pub/sub flows, and a path from local development to distributed runtime execution.\n\nMost agent frameworks start with the agent loop.\n\nAgentLane starts one layer lower: with runtime, identity, and addressed messaging.\n\nThat makes it useful when you want to build AI workflows that are easier to inspect, test, route, scale, and operate.\n\nAgentLane gives you three layers that can be used together or independently:\n\n1. `agentlane.runtime` — delivery, routing, scheduling, pub/sub, and agent identity\n2. `agentlane.models` — prompts, schemas, tools, structured outputs, and model clients\n3. `agentlane.harness` — agent loops, tool execution, handoffs, and high-level agents\n\n```text\n╔════════════════════════════════════════════════════════════════════════════════════╗\n║                                                                                    ║\n║    █████╗  ██████╗ ███████╗███╗   ██╗████████╗██╗      █████╗ ███╗   ██╗███████╗   ║\n║   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██║     ██╔══██╗████╗  ██║██╔════╝   ║\n║   ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   ██║     ███████║██╔██╗ ██║█████╗     ║\n║   ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██║     ██╔══██║██║╚██╗██║██╔══╝     ║\n║   ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████╗██║  ██║██║ ╚████║███████╗   ║\n║   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝   ║\n║                                                                                    ║\n║                reliable, inspectable AI agent workflows                            ║\n║                                                                                    ║\n║              runtime • messaging • model primitives • harness                      ║\n║                                                                                    ║\n║                 from local agents → distributed agent systems                      ║\n║                                                                                    ║\n╚════════════════════════════════════════════════════════════════════════════════════╝\n```\n\n![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)\n![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)\n![PyPI](https://img.shields.io/pypi/v/agentlane.svg)\n\n## Why AgentLane?\n\nMany agent systems start as a prompt, a few tools, and a loop.\n\nThat works for demos. But production systems usually need more structure:\n\n1. stable agent identity across turns and tasks\n2. explicit message routing instead of hidden in-process calls\n3. background specialists that can run independently\n4. fan-out, fan-in, and pub/sub workflows\n5. bounded handoffs between agents and tools\n6. structured model calls that can be tested and reused\n7. a path from local execution to distributed workers\n8. runtime behavior that application code can reason about\n\nAgentLane lets you start with simple local agents, then grow into addressed services, background workers, and multi-agent workflows without changing the core communication model.\n\n## What AgentLane is\n\nAgentLane is a framework for building AI systems as explicit workflows of addressed agents, model calls, tools, messages, and handoffs.\n\nIt is useful when you care about runtime behavior: who receives work, where state lives, how messages are routed, how agents coordinate, and how a local prototype can evolve into a distributed system.\n\nAgentLane is designed for builders who want production AI workflows to be:\n\n1. **Reliable** — agent execution should be structured enough to reason about, test, and debug.\n2. **Inspectable** — important behavior should be visible through explicit messages, tools, handoffs, and runtime boundaries.\n3. **Composable** — agents, model calls, tools, and services should be reusable building blocks.\n4. **Operable** — workflows should have a path from local development to long-running services and distributed workers.\n5. **Bounded** — agent autonomy should live inside application-controlled orchestration, not behind an opaque loop.\n\n## What AgentLane is not\n\nAgentLane is not a single autonomous agent loop.\n\nIt does not try to hide application architecture behind a provider-owned abstraction. The goal is to keep orchestration, routing, and workflow design in application code, where they can be inspected, tested, and evolved.\n\n## Serious domains need serious agent infrastructure\n\nIn low-stakes demos, it may be enough to let an LLM call tools in a loop until it produces a plausible result.\n\nIn serious domains — healthcare, finance, compliance, operations, infrastructure, or any product where users rely on the system — agent behavior needs stronger guarantees.\n\nYou often need to know:\n\n1. which agent or service handled a task\n2. what messages were exchanged\n3. which tools were called\n4. where state was stored\n5. how work was delegated\n6. where a human should review or intervene\n7. how the workflow can be reproduced, tested, and improved\n\nAgentLane is built around that worldview: production agents should be explicit systems, not invisible loops.\n\n## When to use AgentLane\n\nUse AgentLane when you are building AI systems that need one or more of:\n\n1. local agents with tools, delegation, handoffs, or resumable runs\n2. long-lived agents or services with stable identities\n3. explicit routing between agents, tools, and background workers\n4. fan-out, fan-in, or pub/sub workflows\n5. structured model calls with schemas, tools, and provider adapters\n6. a path from local development to distributed execution\n7. application-level control instead of provider-owned orchestration\n\nAgentLane is especially useful when the agent workflow is part of the product architecture, not just a wrapper around a model call.\n\n## Design principles\n\n1. **Runtime first** — agent behavior should be part of the application runtime, not hidden inside a black-box loop.\n2. **Addressable by default** — agents and services should have stable identities that can receive messages directly.\n3. **Composable layers** — use the runtime, model primitives, or harness independently when needed.\n4. **Provider-thin** — keep orchestration in application code instead of outsourcing it to a model provider.\n5. **Local to distributed** — start in one process and preserve the same communication model as the system grows.\n6. **Explicit over magical** — prefer inspectable workflows, messages, tools, and handoffs over implicit control flow.\n7. **Human-compatible** — design workflows so humans can review, intervene, and understand what happened when needed.\n\n## Installation\n\nInstall AgentLane with `uv`:\n\n```bash\nuv add agentlane\n```\n\nIf you are trying the repository directly instead:\n\n```bash\nuv sync --all-extras\n```\n\n## Quick Start\n\nThe harness gives you a simple agent interface when you want one, while still letting you drop down into explicit runtime and messaging primitives as your system grows.\n\nAfter installing the package, define an agent against your model client:\n\n```python\nfrom agentlane.harness import AgentDescriptor\nfrom agentlane.harness.agents import DefaultAgent\n\n\nclass CareNavigationAgent(DefaultAgent):\n    descriptor = AgentDescriptor(\n        name=\"Care Navigation\",\n        model=model,\n        instructions=\"You are a concise patient care navigation agent.\",\n    )\n\n\nagent = CareNavigationAgent()\nresult = await agent.run(\"I feel dizzy after starting a new medication. What should I do first?\")\n```\n\nThis is the simplest entry point.\n\nFor workflows that need explicit routing, background specialists, pub/sub, or distributed execution, use the runtime layer directly.\n\n## Repository examples\n\nIf you are running from a repository checkout, run one runtime example:\n\n```bash\nuv run python examples/runtime/multi_agent_workflow/main.py\n```\n\nRun one high-level harness example with a real model:\n\n```bash\nOPENAI_API_KEY=sk-... uv run python examples/harness/default_agent_quickstart/main.py\n```\n\nThe runtime example shows explicit message passing.\n\n## Choose the layer you need\n\n### Runtime\n\nUse the runtime when agent identity, message routing, pub/sub, scheduling, or distributed execution are part of your application design.\n\nStart here:\n\n1. [Runtime: Engine and Execution](docs/runtime/engine.md)\n2. [Messaging: Routing and Delivery](docs/runtime/messaging.md)\n\n### Models\n\nUse the models layer when you want reusable prompt templates, schemas, structured outputs, tools, or provider clients without adopting the full agent harness.\n\nStart here:\n\n1. [Overview](docs/models/overview.md)\n2. [Prompt Templating](docs/models/prompt-templating.md)\n\n### Harness\n\nUse the harness when you want high-level agents, reusable loops, tool execution, handoffs, or agent-as-tool patterns on top of the lower-level primitives.\n\nStart here:\n\n1. [Default Agents](docs/harness/default-agents.md)\n2. [Architecture](docs/harness/architecture.md)\n3. [Tools](docs/harness/tools.md)\n\n## Documentation\n\nUse the documentation index for the full docs tree:\n\n1. [Documentation Index](docs/README.md)\n2. [Examples Index](examples/README.md)\n\n## Origins\n\nAgentLane was initially inspired by Microsoft AutoGen, but takes a runtime-first approach focused on addressed messaging, explicit orchestration, and local-to-distributed execution.\n\n## Development\n\nFormat, lint, and test:\n\n```bash\n/usr/bin/make format\n/usr/bin/make lint\n/usr/bin/make tests\n```\n\nRun one test with:\n\n```bash\nuv run pytest -s -k \u003ctest_name\u003e\n```\n\n## Contributing\n\n1. Keep changes small and focused.\n2. Add or update tests when behavior changes.\n3. Update public docs and examples when the developer-facing surface changes.\n4. Ensure formatting, linting, and tests pass before opening a PR.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fyasik%2Fagentlane","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fyasik%2Fagentlane","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fyasik%2Fagentlane/lists"}