Bartosz OSA HazEOskA

Bartosz “Osa” Osiński

One of Poland’s leading independent builders in AI Agent Runtime Governance & Verified Execution

Polish AI systems builder from Inowrocław, based in the Netherlands.
Founder / builder: OsaTechGPT.dev · GitHub identity: @HazEOskA

AI Agent Governance · Runtime Control · Capability Boundaries · Immutable Evidence · Independent Verification

_{Search identity: Bartosz Osiński · Bartosz Osinski · Osa · HazEOskA · OsaTechGPT}

 ██████╗ ███████╗ █████╗      ██████╗██╗████████╗██╗   ██╗
██╔═══██╗██╔════╝██╔══██╗    ██╔════╝██║╚══██╔══╝╚██╗ ██╔╝
██║   ██║███████╗███████║    ██║     ██║   ██║    ╚████╔╝
██║   ██║╚════██║██╔══██║    ██║     ██║   ██║     ╚██╔╝
╚██████╔╝███████║██║  ██║    ╚██████╗██║   ██║      ██║
 ╚═════╝ ╚══════╝╚═╝  ╚═╝     ╚═════╝╚═╝   ╚═╝      ╚═╝

      AGENT RUNTIME CITY · PROOF DISTRICT · CLOUD CONTROL GRID

AI Systems Builder · Agent Runtime Architect · Proof-Driven Control Planes
BUILD · ROUTE · VERIFY · OPERATE

┌─────────────────────────────────────────────────────────────────────────────┐
│ 00 // CITY GATE                                                             │
│ Incoming signal: operator / runtime architect detected                      │
│ Mission: turn AI capability into controlled, testable, deployable systems   │
└─────────────────────────────────────────────────────────────────────────────┘

I build agent runtimes, proof systems, AI control planes, cloud workspaces, automation products and operator interfaces.

This GitHub is not a random repo warehouse. It is a builder city: runtimes, control planes, proof boundaries, product districts, research labs and deployment gates.

INTENT
  → ARCHITECTURE
  → ROUTE
  → EXECUTE
  → COLLECT EVIDENCE
  → VERIFY
  → DEPLOY
  → OPERATE

I do not treat AI as a chatbot. I treat it as a programmable execution layer that needs routing, permissions, state, validation, evidence and rollback.

┌─────────────────────────────────────────────────────────────────────────────┐
│ 01 // CITY MAP                                                              │
│ Streets are workflows. Buildings are repos. Gates are trust boundaries.     │
└─────────────────────────────────────────────────────────────────────────────┘

                                [ HYDRA TOWER ]
                                      ▲
                                      │
                              [ CONTROL PLANE ]
                                      ▲
                                      │
              ┌───────────────────────┼───────────────────────┐
              │                       │                       │
     [ EXECUTION FORCE ]      [ PROOF RUNTIME ]      [ CLOUD CONTROL ]
              │                       │                       │
      skill routing / runtime      APR / verifier        Google Cloud
              │                       │                       │
              └───────────────[ AGENT RUNTIME GRID ]─────────┘
                                      │
                         ┌────────────┼────────────┐
                         │            │            │
                  [ BRAIN LAB ] [ PRODUCT FACTORY ] [ LIVE OPS ]
                         │            │            │
                      NEUROSA     builder systems   observability
                                      │
                               [ PROOF REPO STREET ]
                                      │
                               [ CONTACT / WORK ]

┌─────────────────────────────────────────────────────────────────────────────┐
│ 02 // CURRENT BUILDS DISTRICT                                               │
│ The city moved from AI apps into runtimes, proof systems and control planes  │
└─────────────────────────────────────────────────────────────────────────────┘

🐍 HYDRA / Agent Runtime District

The flagship direction is no longer a collection of isolated AI tools. The target is a controlled multi-agent runtime: orchestration, workers, model routing, durable state, evidence, operator control and cloud execution.

DIRECTION:
operator intent
→ orchestrator
→ specialized workers
→ evidence
→ verification
→ synthesis
→ controlled action

Core lanes include HYDRA / Hermes runtime work, coding-agent orchestration and durable agent execution. Private runtime work stays private; public repos below expose the reusable building blocks and proof systems.

🧾 Proof Runtime District

agent-proof-runtime is the proof boundary for autonomous AI work.

MISSION MANIFEST
→ controlled agent output
→ deterministic acceptance
→ event evidence
→ Proof Bundle
→ independent verifier
→ operator verdict

The runtime is intentionally proof-driven: agents may propose work, but they do not get to declare their own execution trustworthy.

⚙️ Execution Force District

osa-execution-force-skills is the canonical skills/control-plane repo.

Current stable line includes versioned skill packages, registry compilation, permissions, evidence ledger, typed rollback, installer/runtime adapters and operator panel. Runtime v2 / resolver work is the active next layer — focused on making skill selection and execution behavior real, not decorative.

🧬 Michael Angelo / Agentic City District

michael-angelo-pro and angelo-agentic-city explore a durable autonomous-agent kernel with:

Durable Mission Runtime
+ Safety Gates
+ Cortex Model Fabric
+ Hermes isolation
+ Atelier Live observability
+ operator takeover / replay

This is the city moving from “agent demo” toward runtime behavior, recovery and observability.

☁️ Cloud Control District

osa-cloud-workspace is the Google Cloud control-plane lane.

GitHub = source
Google Cloud = runtime / infrastructure
Cloud Build → Artifact Registry → Cloud Run
ADC + user-managed Service Account
Evidence before status

The cloud direction is Google Cloud first: deployable workloads, controlled service identities, observable runtime state and explicit infrastructure boundaries.

🧠 Brain Lab

neurosa-human-brain is the research lane for a brain / DSL / intermediate-representation layer used to explore structured reasoning and machine-operable cognition models.

It is R&D — not a marketing claim and not treated as finished infrastructure.

🏭 Product Factory District

The factory layer turns architecture into runnable products and controlled project state.

Systems and lanes:

workflow-control-plane — internal project / execution control plane
coding-agent-platform — coding-agent orchestration lane
OsaTechGPT.dev — public portfolio / product surface
personal-brand-content-os-the-content-engine — content automation lane
osa-live-app-auditor — live application validation tooling

┌─────────────────────────────────────────────────────────────────────────────┐
│ 03 // PROOF REPO STREET                                                     │
│ Public repos are not trophies. They are evidence-bearing system components. │
└─────────────────────────────────────────────────────────────────────────────┘

Building	Repo / System	Purpose	Status
🧾 Proof Tower	`agent-proof-runtime`	Verifiable execution evidence for autonomous AI work	Public / active
⚙️ Execution Force	`osa-execution-force-skills`	Skill registry, policy, evidence and runtime integration	Public / active
🧬 Angelo Runtime	`michael-angelo-pro`	Durable agent kernel and observability	Public / active
🌆 Agentic City	`angelo-agentic-city`	Agent runtime / control surface	Public / active
☁️ Cloud Control	`osa-cloud-workspace`	Google Cloud workspace and control plane	Public / foundation
🧠 Brain Lab	`neurosa-human-brain`	Brain / DSL / IR research	Public / R&D
🛡️ Live Audit	`osa-live-app-auditor`	Live application validation	Public / tooling
🎬 Content Engine	`personal-brand-content-os-the-content-engine`	Content automation system	Public / build lane
🏰 Portfolio Gate	`OsaTechGPT.dev`	Public portfolio / proof surface	Public
🕹️ Control Tower	`workflow-control-plane`	Project / architecture control plane	Private / active
🤖 Coding District	`coding-agent-platform`	Coding-agent orchestration platform	Private / active
🐍 HYDRA Core	HYDRA / Hermes runtime	Multi-agent runtime and orchestration program	Private / active

REPO RULE:
No important repo exists only to look impressive.
It needs a purpose, source-of-truth boundary, validation state and next step.

┌─────────────────────────────────────────────────────────────────────────────┐
│ 04 // OPERATING FLOW ROAD                                                   │
│ The route from idea to shipped and validated system                         │
└─────────────────────────────────────────────────────────────────────────────┘

My standard build route:

Project Intake
→ Market Angle
→ Feature Map
→ Design Direction
→ Architecture Lock
→ Repo Generation
→ Build
→ Live App Test
→ Code Review
→ Deploy
→ Post-Deploy Validation
→ Launch Pack
→ Changelog / Decisions

For serious runtime work I also lock the execution contract:

1. Source of Truth
2. Tools / Permissions
3. Architecture
4. Repo Structure
5. Routing / Execution Flow
6. Evidence / Validation Flow
7. Deployment Boundary
8. Recovery / Rollback

┌─────────────────────────────────────────────────────────────────────────────┐
│ 05 // BOSS LEVELS                                                           │
│ Every failure becomes a gate, a contract or a test                          │
└─────────────────────────────────────────────────────────────────────────────┘

[✓] Random Repo Chaos        → control planes + explicit project state
[✓] AI as Chat Interface     → runtimes, workers, routing and execution contracts
[✓] “Agent Said Done”        → evidence, verifier and proof boundaries
[✓] Single Runtime Thinking  → multi-provider / multi-worker architecture lanes
[✓] Invisible Cloud State    → cloud discovery + evidence-before-status rule
[✓] No Validation            → acceptance suites, live tests and post-deploy checks
[~] Runtime v2               → resolver + native skill execution hardening
[~] HYDRA                    → multi-agent orchestration and durable cloud runtime
[~] Product Factory          → one control surface for project execution

┌─────────────────────────────────────────────────────────────────────────────┐
│ 06 // BUILDER CODE                                                          │
│ Operator logic in public form                                               │
└─────────────────────────────────────────────────────────────────────────────┘

const osa = {
  mode: ["build", "route", "verify", "operate"],
  systems: [
    "agent runtimes",
    "proof boundaries",
    "control planes",
    "cloud workspaces",
    "automation products",
  ],
  rule: "Truth before confidence. Evidence before verdict.",
  flow: "intent → architecture → execute → evidence → verify → deploy → operate",
};

while (building) {
  lockSourceOfTruth();
  definePermissions();
  lockArchitecture();
  routeExecution();
  collectEvidence();
  validateLive();
  shipOrRollback();
}

┌─────────────────────────────────────────────────────────────────────────────┐
│ 07 // PROOF RULES                                                           │
│ No launch without evidence. No runtime claim without a boundary.             │
└─────────────────────────────────────────────────────────────────────────────┘

Every serious project must answer:

What problem does it solve?
What is the source of truth?
Who or what may execute actions?
What is already verified?
What evidence proves it?
What remains UNKNOWN?
What is the rollback path?
What changed in the last session?
What is the next smallest task?

Rules:

NO FAKE CERTAINTY
NO INVISIBLE WORK
NO “DONE” WITHOUT PROOF
NO UNCONTROLLED REPO DRIFT
NO AGENT ACTION WITHOUT A CONTRACT
NO DEPLOY WITHOUT VALIDATION
UNKNOWN IS BETTER THAN INVENTED

┌─────────────────────────────────────────────────────────────────────────────┐
│ 08 // STACK DISTRICT                                                        │
│ Tools are selected for execution control, deployability and evidence        │
└─────────────────────────────────────────────────────────────────────────────┘

AI / Models:
OpenAI / ChatGPT · Claude · Codex · Gemini · NVIDIA · Hermes

Agent Systems:
custom runtimes · orchestration · model routing · durable workers
permissions · evidence ledgers · recovery · operator takeover

Frontend:
Next.js · React · TypeScript · Tailwind

Backend / Runtime:
Python · FastAPI · Node.js · APIs · SQLite · Postgres · Supabase

Cloud / Deploy:
Google Cloud · Cloud Run · Cloud Build · Artifact Registry
Compute Engine · Docker · GitHub Actions · Vercel previews

QA / Proof:
pytest · Playwright · acceptance suites · smoke tests
live validation · hashes · proof bundles · changelogs · rollback

Operator Workflow:
GitHub · local worktrees · Android / DeX · cloud workspace
architecture locks · decision logs · evidence-first reviews

┌─────────────────────────────────────────────────────────────────────────────┐
│ 09 // SIDE STREETS                                                          │
│ Some lanes ship products. Others are laboratories for the next runtime layer │
└─────────────────────────────────────────────────────────────────────────────┘

Proof Runtime Avenue       → APR, verifiers, tamper detection, evidence bundles
Execution Force Road       → skills, resolver, permissions, typed execution
Hydra Core                 → orchestration, workers, durable runtime experiments
Cloud Control Grid         → Google Cloud runtime and infrastructure control
Brain Lab                  → NEUROSA / structured cognition experiments
Agentic City               → Michael Angelo kernel, Atelier Live, observability
Product Factory            → repo → build → test → deploy → launch workflows
Content Engine Street      → automated research and media production systems
God Layer Road             → operator authority, architecture and final decisions

┌─────────────────────────────────────────────────────────────────────────────┐
│ 10 // CONTACT GATE                                                          │
│ Work signal exits here                                                      │
└─────────────────────────────────────────────────────────────────────────────┘

GitHub: @HazEOskA
Web: OsaTechGPT.dev

OPEN TO:
- agent runtime architecture
- AI control planes
- proof-driven automation
- Google Cloud agentic systems
- product MVPs and internal tools
- AI workflow / orchestration systems
- production and operations software

I DO NOT COLLECT RANDOM PROJECTS.
I BUILD A CITY OF SYSTEMS.

EVERY STREET HAS A PURPOSE.
EVERY RUNTIME NEEDS A BOUNDARY.
EVERY CLAIM NEEDS EVIDENCE.
EVERY BUILD MUST SURVIVE VALIDATION.

Build. Route. Verify. Operate.

Navigation Menu