An agentic, self-modifying environment.
Kubernetes for agents: the agents write, review, ship, and improve the software, including themselves. A human sets the goals, approves the critical changes and the high-level designs; the rest runs on its own.
↓ scrollEvery entity in bedrock is a build target in a single Buck2 environment: services, checks, agents, each defined by a custom build rule. Change arrives as jj commits, carried by bedrock's own integration software: a commit is built, and the targets it touches are redeployed, live.
Bedrock itself is a set of communicating containers with its own internal supporting APIs, fully encapsulated and self-hosting; it needs nothing outside itself. There is exactly one way to do things, and a new concept or a new process is just a new build rule.
# a running service
bedrock_service(
name = "integrator",
service_label = "com.bedrock.integrator",
program = ":main",
)
# an agent that writes code, declared like the service
agent_spec(
name = "implementer",
prompts = ["//agents/prompts:implementer"],
harness = "codex", # the AI backend it runs on
)
Bedrock runs on defined processes, and the central one is rigorous code review. Every change is reviewed across multiple rubrics: correctness, security, style, tests. Each rubric is a reviewer agent that examines the change and votes; the change merges when the votes clear, not before.
The process has backstops: security-sensitive paths take stricter votes, and anything an agent judges beyond its authority escalates to the human. Model output varies. What merges does not: the process sets the bar, not the model.
# the reviewer: a security auditor on a Claude model
agent_spec(
name = "fable-auditor",
prompts = ["//agents/prompts:security-review"],
model = "claude-fable-5",
effort = "high",
)
# the process: a required review on every matching change
code_reviewer(
name = "security-review",
agent = ":fable-auditor",
pattern = "**/*.py",
required = True, # nothing merges over its objection
)
The services, the review process, the agents, the deploy machinery: all of it is defined in the same codebase the agents work on, so the loop applies to itself. An agent writes a change to a reviewer, to the runner, to another agent. The change is then reviewed, revised, and merged like any other. Once it lands, bedrock updates in place, and the next change flows through the machinery the last one just improved.
Agents escalate to a human for a vote on the critical changes: deploy machinery, permissions, the rules themselves.
Every conversation in bedrock is kept: user sessions, automated agents at work, the back-and-forth of code reviews. Together they form a record of its life: where work gets stuck, what breaks repeatedly, which pieces of infrastructure are missing.
In the background, that record is analyzed and distilled into a list of issues with bedrock itself. From it, bedrock generates its own tasks. A recurring failure becomes a fix, a missing tool becomes a proposal, and each task flows through the same loop as every other change: proposed, reviewed, shipped. Bedrock improves itself.
Bedrock is a set of hermetic containers: the whole platform is an RL environment and a perfect target for RLVR trajectory gathering (reinforcement learning with verifiable rewards). It diagnoses interesting problems and uses itself to generate trajectories of agentic work: many attempts at the same task, recorded end to end. With GRPO-style reinforcement, the trajectories become training data, and the model is optimized to choose the successful paths more of the time.
The value of a trajectory comes from the same rubrics that gate code review. The reviewer agents score each one, and the scores aggregate into its reward: rubrics as rewards. Bedrock applies its rubrics twice, first to review the code, then to train a better model.
A working prototype, self-hosted end to end.