yaalalabs/agent-kernel/ak-init

<project-name>/
├── pyproject.toml         # Dependencies and project metadata
├── build.sh               # Build script
├── config.yaml            # Agent Kernel configuration
├── <main-file>.py         # Agent definition (demo.py, app.py, or lambda.py)
├── tool.py                # Custom tool functions (if needed)
├── <main-file>_test.py    # Test file
├── README.md              # Project documentation
└── deploy/                # Deployment files (if cloud deployment selected)
    ├── main.tf
    ├── variables.tf
    ├── outputs.tf
    ├── terraform.tfvars
    ├── deploy.sh
    ├── Dockerfile          # For containerized deployments
    └── backend.tf

[project]
name = "<project-name>"
version = "0.1.0"
description = "<description>"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "agentkernel[<extras>]>=0.9.5",
]
 
[dependency-groups]
dev = [
    "agentkernel[test]>=0.9.5",
    "black>=23.0.0",
    "isort>=5.0.0",
    "mypy>=1.0.0",
]
 
[tool.uv]
package = false
 
[tool.isort]
profile = "black"
line_length = 120
 
[tool.black]
line-length = 120
target-version = ["py312"]

from agentkernel.cli import CLI
from agentkernel.openai import OpenAIModule, OpenAIToolBuilder
from agents import Agent
# Import custom tools if needed
# from tool import my_tool
# Define specialized agents
<agent_name> = Agent(
    name="<name>",
    instructions="<instructions for this agent>",
    # tools=OpenAIToolBuilder.bind([my_tool]),  # if tools needed
)
# Define triage agent (if multi-agent)
triage_agent = Agent(
    name="triage",
    instructions="You determine which agent to use based on the user's question.",
    handoffs=[<agent_name>],
)
# Register with Agent Kernel
OpenAIModule([triage_agent, <agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.api import RESTAPI
from agentkernel.openai import OpenAIModule
from agents import Agent
<agent_name> = Agent(
    name="<name>",
    instructions="<instructions>",
)
OpenAIModule([<agent_name>])
if __name__ == "__main__":
    RESTAPI.run()

from agentkernel.aws import Lambda
from agentkernel.openai import OpenAIModule
from agents import Agent
<agent_name> = Agent(
    name="<name>",
    instructions="<instructions>",
)
OpenAIModule([<agent_name>])
handler = Lambda.handler

from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.langgraph import LangGraphModule
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
model = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
<agent_name> = create_react_agent(
    name="<name>",
    tools=[],
    model=model,
    prompt="<instructions>",
)
LangGraphModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.crewai import CrewAIModule
from crewai import Agent
<agent_name> = Agent(
    role="<role>",     # role= is the agent identifier in Agent Kernel
    goal="<goal>",
    backstory="<backstory>",
    verbose=False,
)
# Pass agents directly — Agent Kernel builds the Crew and Task internally per run
CrewAIModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.adk import GoogleADKModule
from google.adk.agents import Agent
<agent_name> = Agent(
    name="<name>",
    model="gemini-2.0-flash",
    instruction="<instructions>",
)
GoogleADKModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.smolagents import SmolagentsModule, SmolagentsToolBuilder
from smolagents import LiteLLMModel, ToolCallingAgent
model = LiteLLMModel(model_id="openai/gpt-4o")
<agent_name> = ToolCallingAgent(
    tools=SmolagentsToolBuilder.bind([]),
    model=model,
    name="<name>",
    description="<instructions>",
)
SmolagentsModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.pydanticai import PydanticAIModule, PydanticAIToolBuilder
from pydantic_ai import Agent
# Provider-agnostic: swap the model string for "anthropic:...", "google-gla:...", etc.
# (install the matching provider extra, e.g. pydantic-ai-slim[anthropic]).
<agent_name> = Agent(
    model="openai:gpt-4o-mini",
    name="<name>",                # required — AK registers agents by name eagerly
    description="<short description>",  # set it — AK reports this as the agent description / A2A summary
    instructions="<instructions>",
    tools=PydanticAIToolBuilder.bind([]),
)
PydanticAIModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
from agentkernel.cli import CLI  # or RESTAPI, Lambda
from agentkernel.maf import MAFModule, MAFToolBuilder
# Swap the client for any other MAF provider (install its package, e.g. agent-framework-anthropic).
<agent_name> = Agent(
    OpenAIChatClient(model="gpt-4.1-mini"),
    name="<name>",                # required — AK registers agents by name immediately
    description="<short description>",  # set it — AK reports this as the agent description / A2A summary
    instructions="<instructions>",
    tools=MAFToolBuilder.bind([]),
)
MAFModule([<agent_name>])
if __name__ == "__main__":
    CLI.main()

from agentkernel.core import ToolContext
def <tool_name>(<params>) -> str:
    """<Tool description — this becomes the tool's description for the LLM>"""
    # Access session context if needed:
    # context = ToolContext.get()
    # session = context.session
    # Tool implementation
    return "<result>"

# Session configuration (if not in-memory)
session:
  type: redis          # redis | dynamodb | cosmosdb
  cache: 256           # LRU cache size (optional)
  redis:
    prefix: "ak:<project>:"
    url: "redis://localhost:6379"
 
# Tracing (optional)
# trace:
#   enabled: true
#   type: langfuse     # langfuse | openllmetry | logfire | cloudwatch

mode: score          # score | llm | fallback (default: fallback)

#!/bin/bash
uv venv && uv sync

import pytest
import pytest_asyncio
from agentkernel.test import Test
pytestmark = pytest.mark.asyncio(loop_scope="session")
@pytest_asyncio.fixture(scope="session", loop_scope="session")
async def test_client():
    test = Test("<main-file>.py")
    await test.start()
    try:
        yield test
    finally:
        await test.stop()
@pytest.mark.order(1)
async def test_basic_response(test_client):
    await test_client.send("<sample question>")
    await test_client.expect(["<expected answer pattern>"])