Setup
Agent
Architecture
Results
GitHub
Paper
The First Step.
Not a Dockerfile generator. An autonomous dual-model agent that reasons, acts, and verifies inside isolated Docker containers — turning hours of Java project setup into minutes of autonomous execution.
git clone https://github.com/Codegass/Setup-Agent.git && cd Setup-Agent && uv syncsag project https://github.com/apache/commons-cli.gitsag ui --port 8765Now you can enjoy the Web UI with one command. Easier to use.
"Role specialization beats raw capacity — pairing a chain-of-thought Thinking Model with a smaller Action Model achieves higher success at 5.5× lower cost than uniformly applying powerful models."
Separates reasoning from execution. A chain-of-thought Thinking Model plans while a smaller Action Model translates plans into tool invocations via function calling. The 12.09 thinking-to-action ratio validates this separation.
SAG operates entirely within Docker containers — not generating Dockerfiles, but interactively exploring and configuring inside them. Zero host pollution, fully reproducible.
Examines concrete evidence on disk — .class files, surefire XML test reports, build artifacts — under a single verdict shared by the CLI, the report, and the exit code. Prevents hallucinations where the agent believes it succeeded without actual completion.
A project setup runs as an engine-driven sequence — provision, analyze, build, test, report. The agent works inside one phase at a time with a clean context window, and the engine advances only on real build evidence.
Six intent-driven tools — build, project, search, bash, files, report — behind verb-based actions. Long build output becomes a retrievable reference instead of flooding the agent's context window.
Completion gates reject work without real artifacts, long builds run detached instead of timing out, and a global iteration and wall-clock cap bound every run. Repeated-action detection breaks stuck loops.
User Input
- Repository URL
- Goal description
Setup Report
- Build & test outcome
- Per-task summary
Thinking Model
- Reasoning
- Plan next action
Action Model
- Function calling
- Tool invocation
Tasks finished?
- Y→ Report
- N→ Thinking
Observation
- Tool Results
- Run Status
- + Validation ↑
Tool Sets
- Bash · Maven · Gradle
- Sys Package · Analyzer
Agent Memory
- Trunk context
- Branch context
Java Project Files
- src/ · pom.xml
- target/ · reports/
Agent State Evaluator
- Rule based
- Detects stuck loops
File Validator
- Rule based
- Ground truth over claims
The ReAct Loop cycles Thinking → Action → Observation → Decision; on each turn it either emits the Setup Report or goes back to Thinking. The Docker Container isolates execution and stores both the Agent Memory and the Java project files in one file system. The Validation System runs out of band — it reads memory and files directly from the container and feeds an independent observation back into the ReAct loop, anchoring reasoning to ground truth rather than the model's own claims.
Thinking Model
- Chain-of-thought reasoning
- Analyze running status
- Examine tool results
- Read validation feedback
- Plan recovery on failure
Action Model
- Translate plan → tools
- Execute in container
- Capture output
Termination
- All tasks done? → validate & report
- Not done? → next iteration
The extreme 12.09 thinking-to-action token ratio validates the architectural separation — the Action Model primarily serves as a command translator, using only 1,372 tokens while the Thinking Model uses 16,584 for complex reasoning. This asymmetry means smaller action models achieve higher success rates at 5.5× lower cost.
Host Machine
- SAG Agent Process
- ReAct Engine
- Context Manager
- Tool Belt
- Validator
Project Files
- src/ pom.xml build.xml
- target/ reports/
Tool Sets · ↕ fallback
- Bash (low)
- Maven / Gradle (mid)
- Sys Package (mid)
- Analyzer (high)
Agent Memory
- Trunk: goal, task list, progress
- Branch: subtask detail
- ↕ merge back on done
SAG operates within Docker containers, not synthesizing Dockerfiles. The agent interactively explores the project, installs dependencies, resolves version conflicts, and builds — all inside the container. Disposable · Reproducible · Safe for untrusted code.
Tool Results
- exit codes
- stdout / stderr
- build logs
Physical Evidence
- .class files
- surefire/*.xml
- compiled JARs
File Validator
- Reads actual files, not model claims
- "Model says success" vs "XML shows 3 fail"
Agent State Evaluator
- Reads agent memory
- Detects stuck loops
- Breaks repeat cycles
Observations
- = tool results
- + file validation
- + state evaluation
LLMs hallucinate — especially about success. The File Validator uses the file system as ground truth, not the model's interpretation of command output. This dual-source feedback means even smaller, cheaper models drive the action loop reliably, enabling the 84.4% success rate with mini models.