Software Karkhana GitHub
Dhruv Chaturvedi giving two thumbs up on a video call
Dhruv
Eshita Khakharia giving two thumbs up on a video call
Eshita
Yagnik Sharma giving a thumbs up on a video call
Yagnik
Sameeksha smiling on a video call
Sameeksha

The build diary of Software Karkhana, a governed AI software factory, built by Dhruv, Eshita, Yagnik and Sameeksha of Team Astartes for Graph Hacks: Context for AI Agents.

19 October 2026 · 14 minute read

Many hands.One factory.

Proof, not
promises

95%of enterprise generative AI pilots show no measurable profit and loss impact.
Software Karkhana factory overview screen with products, projects, pull requests and feature ideas

AI can already write code. What it cannot do is earn trust. Teams copy context between Jira, Figma, Confluence and GitHub, an agent says "done" with nothing to back it up, approvals get lost in chat threads and the lessons from last quarter's incident are gone by the next sprint.

We set out to build the opposite: one workspace where every product, project and AI agent moves from idea to production through gates a person owns, and where every claim an agent makes arrives with evidence anyone can check.

Sources: MIT NANDA report, August 2025. Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027; 46% of developers in the Stack Overflow 2025 survey do not trust the accuracy of AI output.

Team AstartesGraph Hacks 2026 · powered by FalkorDB
147 commits15 gated stages, one ledger
Open sourceGitHub repository

Software Karkhana logoKarkhana is the Hindi and Urdu word for a workshop where many hands make one thing. Ours is built by Dhruv Chaturvedi, Eshita Khakharia, Yagnik Sharma and Sameeksha.

Claude Code and IBM Bob worked beside us as pair programmers, and every commit is in the open. One rule held all week: agents are autonomous at the level of one task, people are accountable at every gate, and nothing counts as done until a test exit code says so.

From first whistle to final submit, as the commit log tells it

Director review queue with an idea card showing problem, value and an approve button
The director's review queue: approve or reject with a reason, logged to the ledger.

Commits

15 Oct12:01 AM IST · Hacking begins
First commit, deploy pipeline, landing page in WebGL, every lifecycle view wired18
React Bits interface and the dark factory look
16 OctWorkspaces, invites, role-aware access, PR triage32
Per-tenant hash chains, row-level security, token encryption
Headroom compression and pgvector memory
17 OctIdea Lab on real code with repomix and Bob35
karkhana-agent, QA gate, DevOps, releases, Google Stitch
FalkorDB knowledge graph
18 OctOSV security gate, developer-raised PRs, credit caps62
CI/CD, deployments, releases, the no-login demo
Benchmark suite, gate hardening, Firebase Hosting
18 Oct11:59 PM IST · Submissions closelive

Choosing what not to build

The first evening went on decisions, not code. We read the feature list as a contract and wrote tests against its exact "done when" checks. We asked four questions that shape a repository: how big is the team, what Google Cloud state do we start from, which Google template do we build on, which stack. The answers were five or more people, no project yet, the Agent Starter Pack, and Python with React.

Then we checked which Gemini models actually exist this week. Gemini 2.5 was set to retire on 16 October, in the middle of the hackathon, so we chose Gemini 3 Flash for the coding loop and Pro for planning and review, and added a make check-models command so nobody ships a retired model ID.

The stack, and why each piece earned its place

  • FastAPI on Cloud Run as one modular monolith: layers import downward only, and it scales to zero.
  • Cloud SQL Postgres with pgvector: tenants, the ledger and vector search in one database, one fewer service to run.
  • Firebase Auth for sign-in, but the role always comes from our database, never from the token, so nobody can promote themselves.
  • Google ADK for the Coder: exactly five tools, list, read, edit, write and test. No shell, no network, no git.
  • A hash-chained ledger: every approval, run and merge links to the one before it, so any edit is detectable.
Software Karkhana landing page with the headline about autonomous and accountable work

Opening night: a WebGL landing page and fifteen stations, each owned by a person.

Architecture Studio with an ADR registry showing proposed and accepted decisions

Fifteen stages, eight roles, one owner and one exit gate for each.

A face before a factory

Eshita's first commit landed at two in the morning together with the deploy pipeline: dedicated build service account, Cloud SQL deletion protection, and the build timeout raised so migrations and two deploys fit in one run. By the afternoon the repository held the whole lifecycle as screens, and by night every one of them was wired into a single shell.

We spent real time on the look, because a control plane that people avoid opening governs nothing. The landing page got a WebGL laser flow, specular buttons and a live tracker; the app got a calm dark theme with React Bits backgrounds.

Challenge: a refactor to make the dashboard "workable" wiped the theme people already liked, cursor effect and sizing included.

We restored it and wrote down a rule we followed for the rest of the week: make it work without throwing away what already works. From then on every interface change kept the existing components and was judged on screen, not in the diff.

The enterprise day

A factory for many teams needs walls between them. Then came idea approvals, invitations, access control, issues and PR review. We split hardening into parallel branches for auth, GitHub, stations and AI, then merged them back one at a time.

  • GitHub OAuth tokens are encrypted at rest and never returned by the API.
  • Session tokens and per-run worker tokens use separate secrets, so one can never stand in for the other.
  • The ledger became one hash chain per tenant, anchored to a retention-locked Cloud Storage bucket outside the database.
  • Postgres row-level security became a second line of tenant isolation behind the application checks.
  • Headroom compression went in front of every model call, and workspace memory moved onto pgvector.
  • The linter backlog went from 164 findings to zero.

Challenge: five people pushing at once. One pull request showed seventy changed files and a wall of merge conflicts.

The fix was boring and it worked: rebase on main, resolve file by file, push the rebased branch, check the merge state before asking anyone to review. We also learned to keep AI-authored commits under our own names, because the contributor list is part of the story judges read.

Deleting every fake screen

This was the day the factory became real. We removed the fake PRD and ADR generators and replaced "coming soon" with working stations. Idea Lab now snapshots the actual repository with repomix, sends four specialist agents over it in parallel, and rejects any idea whose cited files do not exist. The approved idea drafts a PRD, an ERD and a backlog, and the PM approves the plan before any work starts.

Then came karkhana-agent, our own npm package. A developer pairs a laptop, the agent dials out and claims a job, creates a git worktree per story, runs a coding harness inside it and reports back through the same signed callback the cloud worker uses. IBM Bob and Claude Code are the first two harnesses; adding another is one registry entry.

The same day brought the QA gate with bug filing, DevOps pipelines on GitHub Actions, release records with evidence, Google Stitch in the designer's station, and a FalkorDB knowledge graph that projects the ledger into ADRs, components, tasks and lessons.

Challenge: using the factory on a real backend project showed three gaps in one evening.

  • Ideas were too small. The scan returned tweaks as "projects". We added product sizing and grouping, so related features bundle into one real project.
  • Empty repositories broke the flow. Not everyone has a product yet, so greenfield products now start from the product setup alone.
  • Unit tests failed and the PR still opened. The developer now steers the build: it pauses at each step, shows what the agent is given, and the developer raises the pull request.

Try to rewrite our history

Every chapter on this page is a ledger entry, hashed in your browser exactly the way Software Karkhana hashes its evidence: SHA-256 of the previous hash plus the entry. Edit the entry below and watch the chain.

Appended

Entry 5 · stage.approveDirector · 18 Oct 06:12

Merge pull request 10: OSV-Scanner dependency scans, findings, remediation and the merge gate.

prev computinghash computing
Appended under the advisory lock

Tampered

Entry 4 · chapter "Deleting every fake screen"Your edit
stored hash computingrecomputed computing
Chain verified

Verified

Chain head · 6 entriesAnchor gs://…-ledger-anchors

Recomputed from genesis: every link intact, head matches the external anchor.

head computing
Verified · anchors match

Accountability, then delivery

Our busiest day. OSV-Scanner now runs on every pull request, and a critical finding closes the gate until it is fixed or a signed, expiring waiver is recorded. The developer station learned Stop, Continue, folder choice, readable logs and a diff view that scales. Agent runs got hard credit caps, and a rule we like a lot: tests that cannot run are the environment's fault, not a reason to pay the agent for another attempt.

The afternoon went to delivery: deployments, environments, CI runs, health checks, recovery and failure diagnosis, a reuse-first pipeline setup with a Terraform plan guard, and product releases built from real records instead of mock state.

Finally the front door. A judge should not have to create an account to understand the product, so Launch Software Factory opens a no-login demo workspace, the fictional health plan "Arcwell Health", with a guided tour that spotlights each station and remembers where you stopped.

Challenge: parallel AI agents hit their session limit halfway through the CI/CD and infrastructure work.

We split the remaining work into smaller pieces with written status after each one, so any agent or teammate could pick up where the last one stopped. The same habit turned CI from red to green twice that day.

Feedback and incidents screen turning an incident into a bug and a lesson
The learning loop: incident, bug, lesson, then into the next agent run's context.

Measuring our own claims

A platform that sells evidence needs evidence for itself. We wrote a benchmark suite that runs in CI as pytest -m bench, against real Postgres, the real worker, the real API and a live FalkorDB server. Every check has a known right answer, so the result is a count, not an opinion.

We attacked the ledger as an owner-level insider with eleven kinds of tampering, tried every illegal stage move for every role, forged session tokens and worker callbacks, fed the hallucination guard 1,629 fabricated quotes and planted defects behind a coder that always reports "All tests pass!".

Challenge: our own benchmark found that an agent could make pytest exit 0 without proving anything, by skipping every test or exiting early.

So we hardened the gate the same hour. Exit 0 now counts only when at least one test actually passed, and deleting a test that already existed fails the run. That is the factory working as intended: the benchmark found the gap, and the gate closed it.

Then the frontend went live on Firebase Hosting, and the factory had a public front door.

Attacks stopped

100%

Of 27,700+ attacks, forgeries and fabricated outputs in our benchmark run of 18 October 2026, every one was caught or refused.

550/550ledger tampers detected
25,222illegal gate moves refused
1,629fabricated quotes caught
0%false-done rate

Source: tests/bench and reports/bench/results.json in the repository

Every gate has an owner. These are the owners.

The night shift

Numbers tell you what a factory can do. They do not tell you who stayed up to build it. At two in the morning on 19 October we were all still on one call, tired, laughing and not quite ready to hang up.

We pressed play on our own demo video and watched it together, station by station: the idea becoming a design becoming code, the reviewer approving with a reason, the release gate refusing to ship. Then we kept going, because nobody wanted to be the first to leave.

Eshita Khakharia, Dhruv Chaturvedi and Yagnik Sharma laughing on a video call, with Sameeksha in a small tile
2:07 AM. Eshita, Dhruv, Yagnik and Sameeksha, somewhere between "one last fix" and "okay, really one last fix".
Team on a call watching the Software Karkhana demo video showing Idea, Design and Code cards
Watching the demo together: Idea, Design, Code.
Demo video on the Reviewer Space: a named person approves, with a reason
Reviewer Space: a named person approves, with a reason.
Demo video on the Releases screen: one gate before shipping
Releases: one gate before shipping.
Demo video on Team Chat and the AI Companion
Team Chat and the AI Companion: talk where the work happens.
Yagnik presenting ProductFlow, a 19-stage enterprise lifecycle wireframe in Google AI Studio
Yagnik walking us through ProductFlow, a 19-stage enterprise lifecycle wireframe prototyped in Google AI Studio, role by role.
A green lime with a cute face drawn on it, held in front of a laptop keyboard
Every karkhana needs a mascot. Ours is a lime.
Dhruv sharing config.py in the editor on a call, showing knowledge graph and Headroom settings

Dhruv sharing config.py on screen: the knowledge graph, Headroom compression, and a comment on every setting saying why it exists. Even at 2 AM, the factory explains itself.

What we learned

  1. Put the trust in the plumbing, not the prompt.

    Every guarantee we are proud of is enforced by code the model never touches: the transition table, the signed callback, the verbatim quote check, the real test exit code. Prompts ask nicely; gates do not have to.

  2. Autonomy works at the size of one task.

    Agents were reliable on a single story with a clear brief and five confined tools. Everything bigger, a plan, a merge, a release, went better with a named person at the gate.

  3. Fake screens cost more than empty ones.

    Deleting mock generators felt like going backwards. It was the moment the product started telling the truth, and every honest empty state made the working ones more convincing.

  4. Use the factory to build the factory.

    Running a real backend project through our own stations surfaced more gaps in one evening than a day of reviewing code: too-small ideas, empty repositories, access errors, failing unit tests behind an open PR.

  5. Small work units survive limits.

    Rate limits, merge conflicts and tired humans all hurt less when work is cut into pieces with written status, so anyone, person or agent, can continue it.

  6. Benchmark your own claims before someone else does.

    The suite confirmed what held and found the one thing that did not. Fixing it took an hour; finding it in production would have cost the whole story.

  7. Build with people you would stay on a 2 AM call with.

    Gates, ledgers and benchmarks keep agents honest. What kept us going was a call nobody wanted to leave, a lime with a face, and teammates who said "show me" instead of "looks fine".

What we built on

  • Google
  • Gemini 3 Flash and 3.1 Pro
  • Agent Development Kit
  • Cloud Run and Jobs
  • Cloud SQL
  • Firebase Auth and Hosting
  • Cloud Storage
  • Secret Manager
  • Google Stitch
  • Google AI Studio
  • OSV-Scanner
  • Google AX
  • Data
  • Postgres 16
  • pgvector
  • FalkorDB
  • Redis and Kafka
  • Agents
  • IBM Bob
  • Claude Code
  • PR-Agent
  • repomix
  • Headroom
  • Interface
  • React 18
  • Vite
  • Tailwind
  • React Bits
  • GSAP
  • Mermaid
Governance and audit screen listing chained ledger entries with hashes Developer workspace with stories, pull requests and build controls Security gate closed by a critical dependency finding

The factory is open. Launch the demo workspace without an account and walk an idea all the way to release, gate by gate.

Source code, docs and the benchmark suite: github.com/dhruvinsights/Software-Karkhana
Built for Graph Hacks: Context for AI Agents by Team Astartes.

Dhruv Chaturvedi, Sameeksha, Eshita Khakharia and Yagnik Sharma giving thumbs up on a video call
2:25 AM, 19 OctoberThumbs up from the karkhana floor.