-
-
home
-
promts
-
solutions
-
example/solition
-
example/solution2
Inspiration
We run a real production system — 26 microservices on Kubernetes, live 24/7. Every time we needed a status report, a published page, or a diagnostic script, it meant 4 to 6 manual API calls in the right order. There was no intelligence layer that could understand intent and do the work end-to-end.
We didn't want a chatbot. We wanted a Taskmaster — an agent that receives one instruction and autonomously completes the entire workflow: gather data, generate content, write code, test it, publish it, validate it, and save it to memory. No human in the loop. Ever.
The Friction We Brought (BYOF)
The problem is real and personal. We operate a live Kubernetes cluster running 26 microservices 24/7. Every status report required manually calling 4–6 endpoints in the correct order. Every published page meant writing the HTML by hand, uploading it, and hoping it wasn't broken. Every diagnostic script meant writing Python, deploying it, running it, and reading raw JSON.
BARCO Intelligence eliminates every one of those steps. One sentence. The agent gathers live data from all 26 services, writes and executes real Python on the production server, publishes a validated HTML artifact to a live public URL, and saves the result to cross-session persistent memory — autonomously, end-to-end, with a mandatory QA gate after every action.
What It Does
BARCO Intelligence is a three-layer autonomous agent system connected to a live Kubernetes production environment.
Layer 1 — The Orchestrator: Gemini (gemini-3.5-flash) on Google Cloud Run, accessed via the Google GenAI SDK (google-generativeai). Receives a natural language instruction, plans the full workflow, decides which tools to call in parallel or sequentially, and coordinates the entire execution chain — up to 12 agentic rounds per request.
Layer 2 — The Specialists: 23 tools across 6 groups:
- System intelligence (health, status, live signals)
- Semantic memory (1,068+ vectors in Milvus, fastembed 384-dim)
- Agent memory (Ancora — persistent observations across sessions)
- Object storage (MinIO — publishes live webpages with real public URLs)
- Code generation (Aider — writes and executes Python on the production server)
- Infrastructure gateway
Layer 3 — The QA Agent: After every action, the system audits itself:
- After every webpage upload → reads it back, validates the HTML structure, auto-regenerates if broken
- After every code generation → runs the code on the server, catches errors, triggers auto-correction
One message. Complete workflow. The agent gathers data, generates content, publishes it, validates it, saves it to memory, and confirms the result — without a single manual step in between.
How We Built It
Backend: FastAPI on Google Cloud Run, powered by Gemini via the Google GenAI SDK. The agentic loop runs up to 12 rounds per request, with true parallel tool execution via asyncio.gather + asyncio.to_thread — all tools in a single Gemini round fire simultaneously in separate threads.
23 tools wrap real HTTP calls to live microservices running on a Kubernetes cluster (k3s). Every tool returns live data. Nothing is mocked.
Self-validation loop: A mandatory QA pattern encoded directly in the system prompt. After every minio_upload_webpage, the agent calls minio_read_object on the file it just published, validates real HTML structure and content length, and auto-fixes if broken. This fires autonomously — no user prompt needed. Observable in Cloud Logging: minio_upload_webpage is always immediately followed by minio_read_object.
Code generation pipeline: Aider writes complete Python scripts on the production Linux server, executes them, captures output, and feeds results back to the Orchestrator for HTML generation and publishing.
Persistent memory: Three layers — Milvus (semantic vectors), Ancora (agent observations), SQLite (local). The agent saves every significant output automatically. New sessions remember what was built in previous ones with history: [].
Frontend: Flutter (Android + Web). Online: Gemini via Cloud Run, 23 live tools. Offline: Gemma runs on-device via flutter_gemma — same UI, local SQLite memory and RAG, zero downtime.
Challenges We Ran Into
The self-validation paradox. Getting Gemini to trigger QA autonomously — without the user asking — required careful system prompt engineering. Early versions completed the upload and stopped. The self-validation wording had to be precise enough that Gemini treated it as an unconditional obligation, not a suggestion it could skip under time pressure.
Token limits on a tiny on-device model. Gemma 270M has a 1,024 token hard limit in the flutter_gemma runtime. Our initial prompt builder injected memory context, RAG results, knowledge graphs, and goals — then truncated from the beginning, silently removing the system prompt. The model received context fragments without instructions and produced incoherent output. Fix: fall back to a minimal prompt (system + user only) when the enriched prompt exceeds the limit.
Concurrent access to shared services. Three simultaneous agentic conversations exposed a single-threaded bottleneck in Ancora (agent memory). Under parallel load, requests queued and timed out at 8 seconds. We migrated Ancora from HTTPServer to ThreadingHTTPServer with SQLite WAL mode — concurrent reads, serialized writes, zero timeouts.
Production constraints during a hackathon. We were building on a live system. Every test was a real request to real services. We could not mock anything — if a service was down, the agent had to handle it gracefully.
Accomplishments That We're Proud Of
The QA agent fires itself. We never ask it to. It reads back every page it publishes, validates content, and auto-regenerates if broken. Verifiable right now in the live Cloud Run logs.
The agent writes and runs real Python. A complete .py file generated and executed on a production Linux server, making real HTTP connections to 26 live services and publishing the results as a public URL anyone can open.
Persistent memory across sessions. Start a new conversation with history: [] and ask "what have you built for us?" — the agent retrieves exact URLs and decisions from previous sessions via Ancora. Not conversation history. Persistent agent memory.
The system never goes dark. Gemini in the cloud for full power. Gemma on-device for offline resilience. Two Google AI models. One seamless experience. Zero downtime at the AI layer.
Everything is real. 26 Kubernetes pods. Live logs. Published URLs open right now. Not a demo environment.
What We Learned
The hardest part of building a real Taskmaster is not the tools — it is the behavioral contract. Getting an LLM to commit to a full workflow (gather → act → deliver → validate → save) without stopping halfway requires precise system prompt engineering and a loop architecture that forces completion regardless of intermediate results.
We also learned that waiting is narration. A 60-second agentic workflow is not a bug — it is proof that the system is doing real, complex work. Every second visible in the Cloud Run logs is a production system thinking in real time.
What's Next for BARCO Intelligence
- Multi-agent coordination: Spawn specialized sub-agents for concurrent long-running tasks — one writing code while another generates a report
- Scheduled intelligence: Cron-triggered briefings and health dashboards published on a schedule, zero human input
- Webhook integration: External events (Kafka messages, monitoring alerts) trigger the Orchestrator automatically
- Extended code capabilities: SQL queries, shell scripts, infrastructure changes with rollback validation
- Enterprise memory: Distributed vector store for team-wide persistent agent memory with full tenant isolation
Log in or sign up for Devpost to join the conversation.