| title | Automatron |
|---|---|
| colorFrom | indigo |
| sdk | docker |
| app_port | 7860 |
| pinned | false |
| license | mit |
| short_description | Multi-agent decision support for space, quant, e-commerce and real estate |
Multi-agent decision support for high-stakes workflows.
Automatron is a multi-agent system that helps structure complex decisions in four domains: space operations, quantitative finance, e-commerce and real estate.
Instead of sending a request directly to an LLM, Automatron breaks the task into specialised steps, gathers evidence, runs deterministic analysis, verifies the result, and stops at a human approval gate.
The system prepares the decision; a person makes it.
USER REQUEST
|
v
+--------------+
| COORDINATOR |
| Plans the |
| workflow |
+------+-------+
|
+-------------+-------------+
| | |
v v v
RESEARCHER ANALYST EXECUTOR
| | |
+-------------+-------------+
|
v
+----------------------+
| Python / Tools |
| Deterministic work |
+----------+-----------+
|
v
+----------------------+
| VERIFIER |
| Evidence + numbers |
+----------+-----------+
|
+------+------+
| |
Revision Pass
| |
+------<------+
|
v
DECISION BRIEF
|
v
HUMAN APPROVAL
The important distinction is that the LLM is used for flexible reasoning, while important calculations and validation are handled deterministically.
Automatron currently contains 4 sectors and 12 workflows.
| Sector | Workflows |
|---|---|
| Space | Conjunction triage, anomaly root cause, licensing and spectrum |
| Quant | Alpha audit, trade approval, trading-code compliance |
| E-commerce | Return dispute, chargeback representment, seller appeal |
| Real Estate | Due-diligence red flags, permit pre-screen, dispute summary |
All bundled scenarios use synthetic data and fictional organisations and jurisdictions.
The model is not trusted to invent quantitative results in free-form text.
If a decision brief contains a number that was not produced by a deterministic tool, verification fails and the workflow is sent back for revision.
Model reasoning
|
v
Tool execution
|
v
Deterministic result
|
v
Verification
Automatron can research, analyse, calculate, identify risks and prepare recommendations.
It does not:
- Place orders
- Execute trades
- File documents
- Approve permits
- Take regulatory actions
- Make the final decision
The final decision remains with a qualified human.
flowchart TB
USER["User Request"] --> API["FastAPI / Uvicorn"]
API --> GRAPH["LangGraph"]
GRAPH --> C["Coordinator"]
C --> R["Researcher"]
C --> A["Analyst"]
C --> E["Executor"]
R --> Q["LlamaIndex + Qdrant"]
A --> T["Python Tools"]
E --> T
Q --> V["Deterministic Verifier"]
T --> V
V --> LOOP["Capped Revision Loop"]
LOOP --> GRAPH
V --> B["Decision Brief"]
B --> H["Human Approval"]
P["Provider Router"] --> GRAPH
P --> M["6 Providers / 11 Model Slots"]
GRAPH --> AUDIT["Hash-Chained Audit Log"]
| Component | Purpose |
|---|---|
| LangGraph | Agent orchestration and workflow state |
| LlamaIndex | Retrieval pipeline |
| Qdrant | Vector storage |
| Python tools | Deterministic calculations |
| Provider router | Model selection and failover |
| Verifier | Deterministic validation |
| Audit log | Hash-chained decision history |
| FastAPI | API layer |
| Cloud Run | Production deployment |
Automatron does not give every agent unrestricted access.
Plans the workflow and dispatches tasks.
Retrieves relevant sector knowledge and supporting evidence.
Performs quantitative and sector-specific analysis using deterministic tools.
Runs permitted tools and produces structured outputs.
Each role operates under a tool allowlist enforced in code.
The retrieval layer uses LlamaIndex + Qdrant with dense and sparse retrieval.
Request
|
v
Retrieval Layer
/ \
/ \
v v
Dense Search Sparse Search
\ /
\ /
v v
Qdrant
|
v
Relevant Evidence
Knowledge is isolated by sector so workflows operate against the appropriate domain context.
The project is designed around failure cases as well as the normal execution path.
The provider router can fail over when providers encounter:
- Rate limits
- Quota exhaustion
- Context overflow
POST /api/v1/runs supports an Idempotency-Key.
A retry with the same key returns the existing run instead of starting another one.
Request
|
+--> First request --> Start run
|
+--> Retry --> Return existing run
Agent output is checked before it reaches the human approval stage.
The complete workflow can run without API keys using a fake model.
The real tools still execute, allowing the system to be tested without consuming provider quota.
Every decision is recorded in a hash-chained audit log that can be verified.
Automatron is containerized and deployed to Google Cloud Run.
flowchart LR
A["Git Push"] --> B["GitHub Actions"]
B --> C["CI"]
C --> D["Build + Tests"]
D --> E["Workload Identity Federation"]
E --> F["Google Cloud Run"]
F --> G["Health Check"]
G --> H["Live Revision"]
The deployment uses:
- GitHub Actions
- Google Cloud Run
- Artifact Registry
- Secret Manager
- Workload Identity Federation
- Automated post-deployment smoke tests
No long-lived Google Cloud service-account key is stored in the repository.
Current Cloud Run configuration:
Memory: 2 GiB
CPU: 1
Max instances: 1
Concurrency: 20
Timeout: 900 seconds
CI runs on pushes and pull requests and checks:
Lint
|
Notebook build
|
Stored-output checks
|
Offline tests
|
Container build
Deployment runs after CI succeeds:
Push to main
|
v
CI
|
Pass
|
v
Cloud Run deployment
|
v
Health check
|
v
Smoke test
|
v
Live revision
Clone the repository:
git clone https://github.com/Arnavdsp/Automatron.git
cd AutomatronInstall dependencies:
pip install -r requirements-dev.txtBuild the application modules:
python scripts/build_notebooks.pyRun completely offline:
AUTOMATRON_FAKE_LLM=1 python app.pyRun with real providers:
python app.pyRun tests:
pytest -qRun evaluation scenarios:
python tests/eval/run_eval.pyThe offline mode requires no API keys.
Automatron/
|
├── app.py
├── Dockerfile
├── README.md
├── DECISIONS.md
├── requirements.txt
├── requirements-dev.txt
|
├── config/
│ ├── providers.yaml
│ ├── sectors.yaml
│ └── rules/
|
├── data/
│ ├── knowledge/
│ └── samples/
|
├── notebooks/
│ ├── automatron_core.ipynb
│ ├── automatron_ecommerce.ipynb
│ ├── automatron_quant.ipynb
│ ├── automatron_realestate.ipynb
│ └── automatron_space.ipynb
|
├── scripts/
│ └── build_notebooks.py
|
├── tests/
│ ├── eval/
│ ├── integration/
│ ├── live/
│ └── unit/
|
└── .github/
└── workflows/
├── ci.yml
└── deploy.yml
The repository contains DECISIONS.md, which documents the major architectural choices and the reasoning behind them.
It covers why each part was built the way it was, not only what it does.
The project includes:
- Unit tests
- Integration tests
- Golden evaluation scenarios
- Offline fake-model testing
- Deployment smoke tests
- Notebook build checks
- Container build checks
Run the complete offline test suite:
pytest -qRun evaluation scenarios:
python tests/eval/run_eval.pyAutomatron is a portfolio and engineering project.
It is not:
- Investment advice
- Legal advice
- Compliance advice
- Engineering advice
- Regulatory advice
- Operational conjunction screening
All bundled data is synthetic.
The sector rules and thresholds are illustrative and would require independent validation before being used in a real production domain.
Sectors 4
Workflows 12
Model providers 6
Model slots 11
Retrieval Dense + Sparse
Verification Deterministic
Audit Hash-chained
Deployment Cloud Run
CI/CD GitHub Actions
Human approval Required
Areas I want to explore next:
- Distributed execution
- Persistent distributed idempotency
- More rigorous agent evaluation
- Better observability and tracing
- Cost-aware model routing
- Retrieval evaluation
- Stronger policy verification
- Persistent audit storage
Arnav Deshpande
B.Tech, Space Science & Engineering
IIT Indore
GitHub:
https://github.com/Arnavdsp
LLM reasoning
|
v
Tool execution
|
v
Deterministic verification
|
v
Decision brief
|
v
Human decision
Automatron is an exploration of how agentic AI systems can be made more structured, verifiable and controllable when the workflow matters as much as the answer.