Structured Workflows for AI Agents: TypeScript, Python, and MCP
AI agents can complete tasks, generate code, and collaborate with other agents. But as workflows become more complex, a question becomes increasingly important:
How do we make work between AI agents structured, traceable, and easier to hand off?
Passing messages between agents is straightforward. Keeping track of requirements, decisions, results, validation, and unfinished work is much harder.
I've been working on an open-source project to explore a structured approach to this problem.
The idea: Treat agent work as something structured
Imagine a research agent handing its findings to a coding agent.
The coding agent needs more than a summary. It may need the original requirements, constraints, decisions already made, results, unresolved questions, and the next steps.
Without a consistent format, every application ends up inventing its own conventions.
My project explores using Work Orders and Work Reports to represent work and its outcomes in a structured, reusable way.
One project, multiple integrations
I've published three entry points for developers working with different environments.
1. TypeScript / JavaScript
The core package provides the foundation for structured work management, including schemas, validation, lifecycle management, and work handoffs.
Install it:
npm install agent-work-layer
2. MCP integration
The MCP package makes supported work-management operations available through the Model Context Protocol, allowing compatible AI clients to interact with the work layer through MCP tools.
Install it:
npm install agent-work-layer-mcp
The project also explores an MCP gateway that can enforce work-order-specific tool permissions and record tool-call evidence.
3. Python implementation
Agent Work Layer — Python implementation
For Python developers, the project also includes a Python implementation.
This gives Python-based AI-agent applications a way to explore the same broader approach to structured work, without requiring the entire application to be written in TypeScript.
Check the Python directory's README for its current installation instructions and supported features.
What could this look like in practice?
Consider a multi-agent workflow:
- A coordinator defines a task and its constraints.
- A research agent investigates the problem.
- The agent records its results and unresolved questions.
- An implementation agent continues from the recorded work.
- Validation and lifecycle rules help track the outcome.
- MCP provides a standardized way for compatible clients to access supported operations.
The objective is to make agent handoffs less dependent on ad hoc prompts and more dependent on explicit, inspectable work structures.
Why I'm building this
I want to explore how structured work definitions, validated reports, and controlled tool access can improve the reliability of AI-agent workflows.
Rather than every project independently inventing its own work-order format, lifecycle rules, and handoff conventions, could these become reusable infrastructure?
That's the problem I'm working on.
Explore the project
- npm — TypeScript/JavaScript: https://www.npmjs.com/package/agent-work-layer
- npm — MCP integration: https://www.npmjs.com/package/agent-work-layer-mcp
- GitHub — Python implementation: https://github.com/probita-ai/agent-work-layer/tree/main/python
- GitHub — Main repository: https://github.com/probita-ai/agent-work-layer
- **pypi - https://pypi.org/project/agent-work-layer/
I'd love your feedback
If you're building AI agents, agent frameworks, or MCP integrations:
- How do you structure work passed between agents?
- Do you use explicit task and result schemas?
- How do you control tool access for individual tasks?
- Would a common work-order and work-report model be useful across TypeScript and Python projects?
I'm interested in feedback, contributions, and real-world use cases from developers working on these problems.
Top comments (0)